ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- PSigma.lex_iff
theorem lex_iff {a b : Σ' i, α i} :
    Lex r s a b ↔ r a.1 b.1 ∨ ∃ h : a.1 = b.1, s b.1 (h.rec a.2) b.2 
Arguments: {ι : Sort u_1} {α : ι → Sort u_2} {r : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} {a b : (i : ι) ×' α i}
Goal: PSigma.Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd
-- PSigma.Lex.mono
theorem Lex.mono {r₁ r₂ : ι → ι → Prop} {s₁ s₂ : ∀ i, α i → α i → Prop}
    (hr : ∀ a b, r₁ a b → r₂ a b) (hs : ∀ i a b, s₁ i a b → s₂ i a b) {a b : Σ' i, α i}
    (h : Lex r₁ s₁ a b) : Lex r₂ s₂ a b 
Arguments: {ι : Sort u_1} {α : ι → Sort u_2} {r₁ r₂ : ι → ι → Prop} {s₁ s₂ : (i : ι) → α i → α i → Prop} (hr : ∀ (a b : ι), r₁ a b → r₂ a b) (hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b) {a b : (i : ι) ×' α i} (h : PSigma.Lex r₁ s₁ a b)
Goal: PSigma.Lex r₂ s₂ a b
-- PSigma.Lex.mono_left
theorem Lex.mono_left {r₁ r₂ : ι → ι → Prop} {s : ∀ i, α i → α i → Prop}
    (hr : ∀ a b, r₁ a b → r₂ a b) {a b : Σ' i, α i} (h : Lex r₁ s a b) : Lex r₂ s a b 
Arguments: {ι : Sort u_1} {α : ι → Sort u_2} {r₁ r₂ : ι → ι → Prop} {s : (i : ι) → α i → α i → Prop} (hr : ∀ (a b : ι), r₁ a b → r₂ a b) {a b : (i : ι) ×' α i} (h : PSigma.Lex r₁ s a b)
Goal: PSigma.Lex r₂ s a b
-- PSigma.Lex.mono_right
theorem Lex.mono_right {r : ι → ι → Prop} {s₁ s₂ : ∀ i, α i → α i → Prop}
    (hs : ∀ i a b, s₁ i a b → s₂ i a b) {a b : Σ' i, α i} (h : Lex r s₁ a b) : Lex r s₂ a b 
Arguments: {ι : Sort u_1} {α : ι → Sort u_2} {r : ι → ι → Prop} {s₁ s₂ : (i : ι) → α i → α i → Prop} (hs : ∀ (i : ι) (a b : α i), s₁ i a b → s₂ i a b) {a b : (i : ι) ×' α i} (h : PSigma.Lex r s₁ a b)
Goal: PSigma.Lex r s₂ a b
-- Prod.mk.eta
@[simp]
theorem mk.eta : ∀ {p : α × β}, (p.1, p.2) = p
  
Arguments: {α : Type u_1} {β : Type u_2} {p : α × β}
Goal: (p.1, p.2) = p
-- Prod.forall
@[simp]
theorem «forall» {p : α × β → Prop} : (∀ x, p x) ↔ ∀ a b, p (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {p : α × β → Prop}
Goal: (∀ (x : α × β), p x) ↔ ∀ (a : α) (b : β), p (a, b)
-- Prod.exists
@[simp]
theorem «exists» {p : α × β → Prop} : (∃ x, p x) ↔ ∃ a b, p (a, b) 
Arguments: {α : Type u_1} {β : Type u_2} {p : α × β → Prop}
Goal: (∃ x, p x) ↔ ∃ a b, p (a, b)
-- Prod.forall'
theorem forall' {p : α → β → Prop} : (∀ x : α × β, p x.1 x.2) ↔ ∀ a b, p a b 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → β → Prop}
Goal: (∀ (x : α × β), p x.1 x.2) ↔ ∀ (a : α) (b : β), p a b
-- Prod.exists'
theorem exists' {p : α → β → Prop} : (∃ x : α × β, p x.1 x.2) ↔ ∃ a b, p a b 
Arguments: {α : Type u_1} {β : Type u_2} {p : α → β → Prop}
Goal: (∃ x, p x.1 x.2) ↔ ∃ a b, p a b
-- Prod.snd_comp_mk
@[simp]
theorem snd_comp_mk (x : α) : Prod.snd ∘ (Prod.mk x : β → α × β) = id 
Arguments: {α : Type u_1} {β : Type u_2} (x : α)
Goal: Prod.snd ∘ Prod.mk x = id
-- Prod.fst_comp_mk
@[simp]
theorem fst_comp_mk (x : α) : Prod.fst ∘ (Prod.mk x : β → α × β) = Function.const β x 
Arguments: {α : Type u_1} {β : Type u_2} (x : α)
Goal: Prod.fst ∘ Prod.mk x = Function.const β x
-- Prod.map_mk
@[simp, mfld_simps]
theorem map_mk (f : α → γ) (g : β → δ) (a : α) (b : β) : map f g (a, b) = (f a, g b) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → γ) (g : β → δ) (a : α) (b : β)
Goal: Prod.map f g (a, b) = (f a, g b)
-- Prod.map_apply'
theorem map_apply' (f : α → γ) (g : β → δ) (p : α × β) : map f g p = (f p.1, g p.2) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → γ) (g : β → δ) (p : α × β)
Goal: Prod.map f g p = (f p.1, g p.2)
-- Prod.map_fst'
theorem map_fst' (f : α → γ) (g : β → δ) : Prod.fst ∘ map f g = f ∘ Prod.fst 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → γ) (g : β → δ)
Goal: Prod.fst ∘ Prod.map f g = f ∘ Prod.fst
-- Prod.map_snd'
theorem map_snd' (f : α → γ) (g : β → δ) : Prod.snd ∘ map f g = g ∘ Prod.snd 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → γ) (g : β → δ)
Goal: Prod.snd ∘ Prod.map f g = g ∘ Prod.snd
-- Prod.map_comp_map
theorem map_comp_map {ε ζ : Type*} (f : α → β) (f' : γ → δ) (g : β → ε) (g' : δ → ζ) :
    Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f') 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} {ζ : Type u_6} (f : α → β) (f' : γ → δ) (g : β → ε) (g' : δ → ζ)
Goal: Prod.map g g' ∘ Prod.map f f' = Prod.map (g ∘ f) (g' ∘ f')
-- Prod.map_map
theorem map_map {ε ζ : Type*} (f : α → β) (f' : γ → δ) (g : β → ε) (g' : δ → ζ) (x : α × γ) :
    Prod.map g g' (Prod.map f f' x) = Prod.map (g ∘ f) (g' ∘ f') x 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {ε : Type u_5} {ζ : Type u_6} (f : α → β) (f' : γ → δ) (g : β → ε) (g' : δ → ζ) (x : α × γ)
Goal: Prod.map g g' (Prod.map f f' x) = Prod.map (g ∘ f) (g' ∘ f') x
-- Prod.mk.inj_iff
theorem mk.inj_iff {a₁ a₂ : α} {b₁ b₂ : β} : (a₁, b₁) = (a₂, b₂) ↔ a₁ = a₂ ∧ b₁ = b₂ 
Arguments: {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b₁ b₂ : β}
Goal: (a₁, b₁) = (a₂, b₂) ↔ a₁ = a₂ ∧ b₁ = b₂
-- Prod.mk.inj_left
theorem mk.inj_left {α β : Type*} (a : α) : Function.Injective (Prod.mk a : β → α × β) 
Arguments: {α : Type u_5} {β : Type u_6} (a : α)
Goal: Function.Injective (Prod.mk a)
-- Prod.mk.inj_right
theorem mk.inj_right {α β : Type*} (b : β) :
    Function.Injective (fun a ↦ Prod.mk a b : α → α × β) 
Arguments: {α : Type u_5} {β : Type u_6} (b : β)
Goal: Function.Injective fun a => (a, b)
-- Prod.mk_inj_left
lemma mk_inj_left {a : α} {b₁ b₂ : β} : (a, b₁) = (a, b₂) ↔ b₁ = b₂ 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b₁ b₂ : β}
Goal: (a, b₁) = (a, b₂) ↔ b₁ = b₂
-- Prod.mk_inj_right
lemma mk_inj_right {a₁ a₂ : α} {b : β} : (a₁, b) = (a₂, b) ↔ a₁ = a₂ 
Arguments: {α : Type u_1} {β : Type u_2} {a₁ a₂ : α} {b : β}
Goal: (a₁, b) = (a₂, b) ↔ a₁ = a₂
-- Prod.ext_iff
protected theorem ext_iff {p q : α × β} : p = q ↔ p.1 = q.1 ∧ p.2 = q.2 
Arguments: {α : Type u_1} {β : Type u_2} {p q : α × β}
Goal: p = q ↔ p.1 = q.1 ∧ p.2 = q.2
-- Prod.map_def
theorem map_def {f : α → γ} {g : β → δ} : Prod.map f g = fun p : α × β ↦ (f p.1, g p.2) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → γ} {g : β → δ}
Goal: Prod.map f g = fun p => (f p.1, g p.2)
-- Prod.id_prod
theorem id_prod : (fun p : α × β ↦ (p.1, p.2)) = id 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: (fun p => (p.1, p.2)) = id
-- Prod.map_id
@[simp] lemma map_id : Prod.map (@id α) (@id β) = id 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Prod.map id id = id
-- Prod.map_id'
@[simp] lemma map_id' : Prod.map (fun a : α ↦ a) (fun b : β ↦ b) = fun x ↦ x 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: (Prod.map (fun a => a) fun b => b) = fun x => x
-- Prod.map_iterate
@[simp]
theorem map_iterate (f : α → α) (g : β → β) (n : ℕ) :
    (Prod.map f g)^[n] = Prod.map f^[n] g^[n] 
Arguments: {α : Type u_1} {β : Type u_2} (f : α → α) (g : β → β) (n : ℕ)
Goal: (Prod.map f g)^[n] = Prod.map f^[n] g^[n]
-- Prod.fst_surjective
theorem fst_surjective [h : Nonempty β] : Function.Surjective (@fst α β) 
Arguments: {α : Type u_1} {β : Type u_2} [h : Nonempty β]
Goal: Function.Surjective Prod.fst
-- Prod.snd_surjective
theorem snd_surjective [h : Nonempty α] : Function.Surjective (@snd α β) 
Arguments: {α : Type u_1} {β : Type u_2} [h : Nonempty α]
Goal: Function.Surjective Prod.snd
-- Prod.fst_injective
theorem fst_injective [Subsingleton β] : Function.Injective (@fst α β) 
Arguments: {α : Type u_1} {β : Type u_2} [Subsingleton β]
Goal: Function.Injective Prod.fst
-- Prod.snd_injective
theorem snd_injective [Subsingleton α] : Function.Injective (@snd α β) 
Arguments: {α : Type u_1} {β : Type u_2} [Subsingleton α]
Goal: Function.Injective Prod.snd
-- Prod.swap_swap
@[simp]
theorem swap_swap : ∀ x : α × β, swap (swap x) = x
  
Arguments: {α : Type u_1} {β : Type u_2} (x : α × β)
Goal: x.swap.swap = x
-- Prod.fst_swap
@[simp]
theorem fst_swap {p : α × β} : (swap p).1 = p.2 
Arguments: {α : Type u_1} {β : Type u_2} {p : α × β}
Goal: p.swap.1 = p.2
-- Prod.snd_swap
@[simp]
theorem snd_swap {p : α × β} : (swap p).2 = p.1 
Arguments: {α : Type u_1} {β : Type u_2} {p : α × β}
Goal: p.swap.2 = p.1
-- Prod.swap_prod_mk
@[simp]
theorem swap_prod_mk {a : α} {b : β} : swap (a, b) = (b, a) 
Arguments: {α : Type u_1} {β : Type u_2} {a : α} {b : β}
Goal: (a, b).swap = (b, a)
-- Prod.swap_swap_eq
@[simp]
theorem swap_swap_eq : swap ∘ swap = @id (α × β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Prod.swap ∘ Prod.swap = id
-- Prod.swap_leftInverse
@[simp]
theorem swap_leftInverse : Function.LeftInverse (@swap α β) swap 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.LeftInverse Prod.swap Prod.swap
-- Prod.swap_rightInverse
@[simp]
theorem swap_rightInverse : Function.RightInverse (@swap α β) swap 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.RightInverse Prod.swap Prod.swap
-- Prod.swap_injective
theorem swap_injective : Function.Injective (@swap α β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.Injective Prod.swap
-- Prod.swap_surjective
theorem swap_surjective : Function.Surjective (@swap α β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.Surjective Prod.swap
-- Prod.swap_bijective
theorem swap_bijective : Function.Bijective (@swap α β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.Bijective Prod.swap
-- Prod.swap_inj
@[simp]
theorem swap_inj {p q : α × β} : swap p = swap q ↔ p = q 
Arguments: {α : Type u_1} {β : Type u_2} {p q : α × β}
Goal: p.swap = q.swap ↔ p = q
-- Prod.map_comp_swap
theorem map_comp_swap (f : α → β) (g : γ → δ) :
    Prod.map f g ∘ Prod.swap = Prod.swap ∘ Prod.map g f 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} (f : α → β) (g : γ → δ)
Goal: Prod.map f g ∘ Prod.swap = Prod.swap ∘ Prod.map g f
-- Prod.eq_iff_fst_eq_snd_eq
theorem eq_iff_fst_eq_snd_eq : ∀ {p q : α × β}, p = q ↔ p.1 = q.1 ∧ p.2 = q.2
  
Arguments: {α : Type u_1} {β : Type u_2} {p q : α × β}
Goal: p = q ↔ p.1 = q.1 ∧ p.2 = q.2
-- Prod.fst_eq_iff
theorem fst_eq_iff : ∀ {p : α × β} {x : α}, p.1 = x ↔ p = (x, p.2)
  
Arguments: {α : Type u_1} {β : Type u_2} {p : α × β} {x : α}
Goal: p.1 = x ↔ p = (x, p.2)
-- Prod.snd_eq_iff
theorem snd_eq_iff : ∀ {p : α × β} {x : β}, p.2 = x ↔ p = (p.1, x)
  
Arguments: {α : Type u_1} {β : Type u_2} {p : α × β} {x : β}
Goal: p.2 = x ↔ p = (p.1, x)
-- Prod.lex_iff
lemma lex_iff : Prod.Lex r s x y ↔ r x.1 y.1 ∨ x.1 = y.1 ∧ s x.2 y.2 
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {x y : α × β}
Goal: Prod.Lex r s x y ↔ r x.1 y.1 ∨ x.1 = y.1 ∧ s x.2 y.2
-- Prod.Lex.refl_left
@[refl]
theorem Lex.refl_left (r : α → α → Prop) (s : β → β → Prop) [IsRefl α r] : ∀ x, Prod.Lex r s x x
  
Arguments: {α : Type u_1} {β : Type u_2} (r : α → α → Prop) (s : β → β → Prop) [IsRefl α r] (x : α × β)
Goal: Prod.Lex r s x x
-- Prod.Lex.refl_right
@[refl]
theorem Lex.refl_right (r : α → α → Prop) (s : β → β → Prop) [IsRefl β s] : ∀ x, Prod.Lex r s x x
  
Arguments: {α : Type u_1} {β : Type u_2} (r : α → α → Prop) (s : β → β → Prop) [IsRefl β s] (x : α × β)
Goal: Prod.Lex r s x x
-- Prod.Lex.trans
@[trans]
theorem Lex.trans {r : α → α → Prop} {s : β → β → Prop} [IsTrans α r] [IsTrans β s] :
    ∀ {x y z : α × β}, Prod.Lex r s x y → Prod.Lex r s y z → Prod.Lex r s x z
  
Arguments: {α : Type u_1} {β : Type u_2} {r : α → α → Prop} {s : β → β → Prop} [IsTrans α r] [IsTrans β s] {x y z : α × β}
Goal: Prod.Lex r s x y → Prod.Lex r s y z → Prod.Lex r s x z
-- Function.Injective.prodMap
theorem Injective.prodMap (hf : Injective f) (hg : Injective g) : Injective (map f g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → γ} {g : β → δ} (hf : Function.Injective f) (hg : Function.Injective g)
Goal: Function.Injective (Prod.map f g)
-- Function.Surjective.prodMap
theorem Surjective.prodMap (hf : Surjective f) (hg : Surjective g) : Surjective (map f g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → γ} {g : β → δ} (hf : Function.Surjective f) (hg : Function.Surjective g)
Goal: Function.Surjective (Prod.map f g)
-- Function.Bijective.prodMap
theorem Bijective.prodMap (hf : Bijective f) (hg : Bijective g) : Bijective (map f g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f : α → γ} {g : β → δ} (hf : Function.Bijective f) (hg : Function.Bijective g)
Goal: Function.Bijective (Prod.map f g)
-- Function.LeftInverse.prodMap
theorem LeftInverse.prodMap (hf : LeftInverse f₁ f₂) (hg : LeftInverse g₁ g₂) :
    LeftInverse (map f₁ g₁) (map f₂ g₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α} {g₂ : δ → γ} (hf : Function.LeftInverse f₁ f₂) (hg : Function.LeftInverse g₁ g₂)
Goal: Function.LeftInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂)
-- Function.RightInverse.prodMap
theorem RightInverse.prodMap :
    RightInverse f₁ f₂ → RightInverse g₁ g₂ → RightInverse (map f₁ g₁) (map f₂ g₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α} {g₂ : δ → γ}
Goal: Function.RightInverse f₁ f₂ → Function.RightInverse g₁ g₂ → Function.RightInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂)
-- Function.Involutive.prodMap
theorem Involutive.prodMap {f : α → α} {g : β → β} :
    Involutive f → Involutive g → Involutive (map f g) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α → α} {g : β → β}
Goal: Function.Involutive f → Function.Involutive g → Function.Involutive (Prod.map f g)
-- Prod.map_injective
@[simp]
theorem map_injective [Nonempty α] [Nonempty β] {f : α → γ} {g : β → δ} :
    Injective (map f g) ↔ Injective f ∧ Injective g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [Nonempty α] [Nonempty β] {f : α → γ} {g : β → δ}
Goal: Function.Injective (Prod.map f g) ↔ Function.Injective f ∧ Function.Injective g
-- Prod.map_surjective
@[simp]
theorem map_surjective [Nonempty γ] [Nonempty δ] {f : α → γ} {g : β → δ} :
    Surjective (map f g) ↔ Surjective f ∧ Surjective g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [Nonempty γ] [Nonempty δ] {f : α → γ} {g : β → δ}
Goal: Function.Surjective (Prod.map f g) ↔ Function.Surjective f ∧ Function.Surjective g
-- Prod.map_bijective
@[simp]
theorem map_bijective [Nonempty α] [Nonempty β] {f : α → γ} {g : β → δ} :
    Bijective (map f g) ↔ Bijective f ∧ Bijective g 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [Nonempty α] [Nonempty β] {f : α → γ} {g : β → δ}
Goal: Function.Bijective (Prod.map f g) ↔ Function.Bijective f ∧ Function.Bijective g
-- Prod.map_leftInverse
@[simp]
theorem map_leftInverse [Nonempty β] [Nonempty δ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α}
    {g₂ : δ → γ} : LeftInverse (map f₁ g₁) (map f₂ g₂) ↔ LeftInverse f₁ f₂ ∧ LeftInverse g₁ g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [Nonempty β] [Nonempty δ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α} {g₂ : δ → γ}
Goal: Function.LeftInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂) ↔ Function.LeftInverse f₁ f₂ ∧ Function.LeftInverse g₁ g₂
-- Prod.map_rightInverse
@[simp]
theorem map_rightInverse [Nonempty α] [Nonempty γ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α}
    {g₂ : δ → γ} : RightInverse (map f₁ g₁) (map f₂ g₂) ↔ RightInverse f₁ f₂ ∧ RightInverse g₁ g₂ 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [Nonempty α] [Nonempty γ] {f₁ : α → β} {g₁ : γ → δ} {f₂ : β → α} {g₂ : δ → γ}
Goal: Function.RightInverse (Prod.map f₁ g₁) (Prod.map f₂ g₂) ↔ Function.RightInverse f₁ f₂ ∧ Function.RightInverse g₁ g₂
-- Prod.map_involutive
@[simp]
theorem map_involutive [Nonempty α] [Nonempty β] {f : α → α} {g : β → β} :
    Involutive (map f g) ↔ Involutive f ∧ Involutive g 
Arguments: {α : Type u_1} {β : Type u_2} [Nonempty α] [Nonempty β] {f : α → α} {g : β → β}
Goal: Function.Involutive (Prod.map f g) ↔ Function.Involutive f ∧ Function.Involutive g
-- List.TProd.fst_mk
@[simp]
theorem fst_mk (i : ι) (l : List ι) (f : ∀ i, α i) : (TProd.mk (i :: l) f).1 = f i 
Arguments: {ι : Type u} {α : ι → Type v} (i : ι) (l : List ι) (f : (i : ι) → α i)
Goal: (List.TProd.mk (i :: l) f).1 = f i
-- List.TProd.snd_mk
@[simp]
theorem snd_mk (i : ι) (l : List ι) (f : ∀ i, α i) :
    (TProd.mk.{u,v} (i :: l) f).2 = TProd.mk.{u,v} l f 
Arguments: {ι : Type u} {α : ι → Type v} (i : ι) (l : List ι) (f : (i : ι) → α i)
Goal: (List.TProd.mk (i :: l) f).2 = List.TProd.mk l f
-- List.TProd.elim_self
@[simp]
theorem elim_self (v : TProd α (i :: l)) : v.elim (l.mem_cons_self i) = v.1 
Arguments: {ι : Type u} {α : ι → Type v} {i : ι} {l : List ι} [DecidableEq ι] (v : List.TProd α (i :: l))
Goal: v.elim ⋯ = v.1
-- List.TProd.elim_of_ne
@[simp]
theorem elim_of_ne (hj : j ∈ i :: l) (hji : j ≠ i) (v : TProd α (i :: l)) :
    v.elim hj = TProd.elim v.2 ((List.mem_cons.mp hj).resolve_left hji) 
Arguments: {ι : Type u} {α : ι → Type v} {i j : ι} {l : List ι} [DecidableEq ι] (hj : j ∈ i :: l) (hji : j ≠ i) (v : List.TProd α (i :: l))
Goal: v.elim hj = List.TProd.elim v.2 ⋯
-- List.TProd.elim_of_mem
@[simp]
theorem elim_of_mem (hl : (i :: l).Nodup) (hj : j ∈ l) (v : TProd α (i :: l)) :
    v.elim (mem_cons_of_mem _ hj) = TProd.elim v.2 hj 
Arguments: {ι : Type u} {α : ι → Type v} {i j : ι} {l : List ι} [DecidableEq ι] (hl : (i :: l).Nodup) (hj : j ∈ l) (v : List.TProd α (i :: l))
Goal: v.elim ⋯ = List.TProd.elim v.2 hj
-- List.TProd.elim_mk
theorem elim_mk : ∀ (l : List ι) (f : ∀ i, α i) {i : ι} (hi : i ∈ l), (TProd.mk l f).elim hi = f i
  
Arguments: {ι : Type u} {α : ι → Type v} [DecidableEq ι] (l : List ι) (f : (i : ι) → α i) {i : ι} (hi : i ∈ l)
Goal: (List.TProd.mk l f).elim hi = f i
-- List.TProd.ext
@[ext]
theorem ext :
    ∀ {l : List ι} (_ : l.Nodup) {v w : TProd α l}
      (_ : ∀ (i) (hi : i ∈ l), v.elim hi = w.elim hi), v = w
  
Arguments: {ι : Type u} {α : ι → Type v} [DecidableEq ι] {l : List ι}
Goal: l.Nodup → ∀ {v w : List.TProd α l}, (∀ (i : ι) (hi : i ∈ l), v.elim hi = w.elim hi) → v = w
-- List.TProd.mk_elim
theorem mk_elim (hnd : l.Nodup) (h : ∀ i, i ∈ l) (v : TProd α l) : TProd.mk l (v.elim' h) = v 
Arguments: {ι : Type u} {α : ι → Type v} {l : List ι} [DecidableEq ι] (hnd : l.Nodup) (h : ∀ (i : ι), i ∈ l) (v : List.TProd α l)
Goal: List.TProd.mk l (List.TProd.elim' h v) = v
-- Set.mk_preimage_tprod
theorem mk_preimage_tprod :
    ∀ (l : List ι) (t : ∀ i, Set (α i)), TProd.mk l ⁻¹' Set.tprod l t = { i | i ∈ l }.pi t
  
Arguments: {ι : Type u} {α : ι → Type v} (l : List ι) (t : (i : ι) → Set (α i))
Goal: List.TProd.mk l ⁻¹' Set.tprod l t = {i | i ∈ l}.pi t
-- Set.elim_preimage_pi
theorem elim_preimage_pi [DecidableEq ι] {l : List ι} (hnd : l.Nodup) (h : ∀ i, i ∈ l)
    (t : ∀ i, Set (α i)) : TProd.elim' h ⁻¹' pi univ t = Set.tprod l t 
Arguments: {ι : Type u} {α : ι → Type v} [DecidableEq ι] {l : List ι} (hnd : l.Nodup) (h : ∀ (i : ι), i ∈ l) (t : (i : ι) → Set (α i))
Goal: List.TProd.elim' h ⁻¹' Set.univ.pi t = Set.tprod l t
-- Finset.map_val
@[simp]
theorem map_val (f : α ↪ β) (s : Finset α) : (map f s).1 = s.1.map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) (s : Finset α)
Goal: (Finset.map f s).val = Multiset.map (⇑f) s.val
-- Finset.map_empty
@[simp]
theorem map_empty (f : α ↪ β) : (∅ : Finset α).map f = ∅ 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β)
Goal: Finset.map f ∅ = ∅
-- Finset.mem_map
@[simp]
theorem mem_map {b : β} : b ∈ s.map f ↔ ∃ a ∈ s, f a = b 
Arguments: {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {b : β}
Goal: b ∈ Finset.map f s ↔ ∃ a ∈ s, f a = b
-- Finset.mem_map_equiv
@[simp 1100]
theorem mem_map_equiv {f : α ≃ β} {b : β} : b ∈ s.map f.toEmbedding ↔ f.symm b ∈ s 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {f : α ≃ β} {b : β}
Goal: b ∈ Finset.map f.toEmbedding s ↔ f.symm b ∈ s
-- Finset.mem_map'
@[simp 1100]
theorem mem_map' (f : α ↪ β) {a} {s : Finset α} : f a ∈ s.map f ↔ a ∈ s 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}
Goal: f a ∈ Finset.map f s ↔ a ∈ s
-- Finset.mem_map_of_mem
theorem mem_map_of_mem (f : α ↪ β) {a} {s : Finset α} : a ∈ s → f a ∈ s.map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) {a : α} {s : Finset α}
Goal: a ∈ s → f a ∈ Finset.map f s
-- Finset.forall_mem_map
theorem forall_mem_map {f : α ↪ β} {s : Finset α} {p : ∀ a, a ∈ s.map f → Prop} :
    (∀ y (H : y ∈ s.map f), p y H) ↔ ∀ x (H : x ∈ s), p (f x) (mem_map_of_mem _ H) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s : Finset α} {p : (a : β) → a ∈ Finset.map f s → Prop}
Goal: (∀ (y : β) (H : y ∈ Finset.map f s), p y H) ↔ ∀ (x : α) (H : x ∈ s), p (f x) ⋯
-- Finset.apply_coe_mem_map
theorem apply_coe_mem_map (f : α ↪ β) (s : Finset α) (x : s) : f x ∈ s.map f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) (s : Finset α) (x : { x // x ∈ s })
Goal: f ↑x ∈ Finset.map f s
-- Finset.coe_map
@[simp, norm_cast]
theorem coe_map (f : α ↪ β) (s : Finset α) : (s.map f : Set β) = f '' s 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) (s : Finset α)
Goal: ↑(Finset.map f s) = ⇑f '' ↑s
-- Finset.coe_map_subset_range
theorem coe_map_subset_range (f : α ↪ β) (s : Finset α) : (s.map f : Set β) ⊆ Set.range f 
Arguments: {α : Type u_1} {β : Type u_2} (f : α ↪ β) (s : Finset α)
Goal: ↑(Finset.map f s) ⊆ Set.range ⇑f
-- Finset.map_perm
theorem map_perm {σ : Equiv.Perm α} (hs : { a | σ a ≠ a } ⊆ s) : s.map (σ : α ↪ α) = s 
Arguments: {α : Type u_1} {s : Finset α} {σ : Equiv.Perm α} (hs : {a | σ a ≠ a} ⊆ ↑s)
Goal: Finset.map (Equiv.toEmbedding σ) s = s
-- Finset.map_toFinset
theorem map_toFinset [DecidableEq α] [DecidableEq β] {s : Multiset α} :
    s.toFinset.map f = (s.map f).toFinset 
Arguments: {α : Type u_1} {β : Type u_2} {f : α ↪ β} [DecidableEq α] [DecidableEq β] {s : Multiset α}
Goal: Finset.map f s.toFinset = (Multiset.map (⇑f) s).toFinset
-- Finset.map_refl
@[simp]
theorem map_refl : s.map (Embedding.refl _) = s 
Arguments: {α : Type u_1} {s : Finset α}
Goal: Finset.map (Function.Embedding.refl α) s = s
-- Finset.map_cast_heq
@[simp]
theorem map_cast_heq {α β} (h : α = β) (s : Finset α) :
    HEq (s.map (Equiv.cast h).toEmbedding) s 
Arguments: {α β : Type u_4} (h : α = β) (s : Finset α)
Goal: HEq (Finset.map (Equiv.cast h).toEmbedding s) s
-- Finset.map_map
theorem map_map (f : α ↪ β) (g : β ↪ γ) (s : Finset α) : (s.map f).map g = s.map (f.trans g) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (f : α ↪ β) (g : β ↪ γ) (s : Finset α)
Goal: Finset.map g (Finset.map f s) = Finset.map (f.trans g) s
-- Finset.map_comm
theorem map_comm {β'} {f : β ↪ γ} {g : α ↪ β} {f' : α ↪ β'} {g' : β' ↪ γ}
    (h_comm : ∀ a, f (g a) = g' (f' a)) : (s.map g).map f = (s.map f').map g' 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} {s : Finset α} {β' : Type u_4} {f : β ↪ γ} {g : α ↪ β} {f' : α ↪ β'} {g' : β' ↪ γ} (h_comm : ∀ (a : α), f (g a) = g' (f' a))
Goal: Finset.map f (Finset.map g s) = Finset.map g' (Finset.map f' s)
-- Function.Semiconj.finset_map
theorem _root_.Function.Semiconj.finset_map {f : α ↪ β} {ga : α ↪ α} {gb : β ↪ β}
    (h : Function.Semiconj f ga gb) : Function.Semiconj (map f) (map ga) (map gb) 
Arguments: {α : Type u_1} {β : Type u_2} {f : α ↪ β} {ga : α ↪ α} {gb : β ↪ β} (h : Function.Semiconj ⇑f ⇑ga ⇑gb)
Goal: Function.Semiconj (Finset.map f) (Finset.map ga) (Finset.map gb)
-- Function.Commute.finset_map
theorem _root_.Function.Commute.finset_map {f g : α ↪ α} (h : Function.Commute f g) :
    Function.Commute (map f) (map g) 
Arguments: {α : Type u_1} {f g : α ↪ α} (h : Function.Commute ⇑f ⇑g)
Goal: Function.Commute (Finset.map f) (Finset.map g)
-- Finset.map_subset_map
@[simp]
theorem map_subset_map {s₁ s₂ : Finset α} : s₁.map f ⊆ s₂.map f ↔ s₁ ⊆ s₂ 
Arguments: {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s₁ s₂ : Finset α}
Goal: Finset.map f s₁ ⊆ Finset.map f s₂ ↔ s₁ ⊆ s₂
-- Finset.subset_map_symm
theorem subset_map_symm {t : Finset β} {f : α ≃ β} : s ⊆ t.map f.symm ↔ s.map f ⊆ t 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {f : α ≃ β}
Goal: s ⊆ Finset.map f.symm.toEmbedding t ↔ Finset.map f.toEmbedding s ⊆ t
-- Finset.map_symm_subset
theorem map_symm_subset {t : Finset β} {f : α ≃ β} : t.map f.symm ⊆ s ↔ t ⊆ s.map f 
Arguments: {α : Type u_1} {β : Type u_2} {s : Finset α} {t : Finset β} {f : α ≃ β}
Goal: Finset.map f.symm.toEmbedding t ⊆ s ↔ t ⊆ Finset.map f.toEmbedding s