ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.sigmaCongrRight_symm
theorem sigmaCongrRight_symm {α} {β₁ β₂ : α → Type*} (F : ∀ a, β₁ a ≃ β₂ a) :
    (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm 
Arguments: {α : Type u_3} {β₁ : α → Type u_1} {β₂ : α → Type u_2} (F : (a : α) → β₁ a ≃ β₂ a)
Goal: (Equiv.sigmaCongrRight F).symm = Equiv.sigmaCongrRight fun a => (F a).symm
-- Equiv.sigmaCongrRight_refl
theorem sigmaCongrRight_refl {α} {β : α → Type*} :
    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) 
Arguments: {α : Type u_2} {β : α → Type u_1}
Goal: (Equiv.sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl ((a : α) × β a)
-- Equiv.Perm.sigmaCongrRight_trans
@[simp] theorem sigmaCongrRight_trans {α} {β : α → Sort _}
    (F : ∀ a, Perm (β a)) (G : ∀ a, Perm (β a)) :
    (sigmaCongrRight F).trans (sigmaCongrRight G) = sigmaCongrRight fun a => (F a).trans (G a) 
Arguments: {α : Type u_1} {β : α → Type u_2} (F G : (a : α) → Equiv.Perm (β a))
Goal: Equiv.trans (Equiv.Perm.sigmaCongrRight F) (Equiv.Perm.sigmaCongrRight G) =
  Equiv.Perm.sigmaCongrRight fun a => Equiv.trans (F a) (G a)
-- Equiv.Perm.sigmaCongrRight_symm
@[simp] theorem sigmaCongrRight_symm {α} {β : α → Sort _} (F : ∀ a, Perm (β a)) :
    (sigmaCongrRight F).symm = sigmaCongrRight fun a => (F a).symm 
Arguments: {α : Type u_1} {β : α → Type u_2} (F : (a : α) → Equiv.Perm (β a))
Goal: Equiv.symm (Equiv.Perm.sigmaCongrRight F) = Equiv.Perm.sigmaCongrRight fun a => Equiv.symm (F a)
-- Equiv.Perm.sigmaCongrRight_refl
@[simp] theorem sigmaCongrRight_refl {α} {β : α → Sort _} :
    (sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl (Σ a, β a) 
Arguments: {α : Type u_1} {β : α → Type u_2}
Goal: (Equiv.Perm.sigmaCongrRight fun a => Equiv.refl (β a)) = Equiv.refl ((a : α) × β a)
-- Equiv.sigmaCongrLeft_apply
@[simps apply] def sigmaCongrLeft {α₁ α₂ : Type*} {β : α₂ → Sort _} (e : α₁ ≃ α₂) :
    (Σ a : α₁, β (e a)) ≃ Σ a : α₂, β a 
Arguments: {α₁ : Type u_1} {α₂ : Type u_2} {β : α₂ → Type u_3} (e : α₁ ≃ α₂) (a : (a : α₁) × β (e a))
Goal: e.sigmaCongrLeft a = ⟨e a.fst, a.snd⟩
-- Equiv.sigmaEquivProd_apply
@[simps (config := { attrs := [`mfld_simps] }) apply symm_apply]
def sigmaEquivProd (α β : Type*) : (Σ _ : α, β) ≃ α × β 
Arguments: (α : Type u_1) (β : Type u_2) (a : (_ : α) × β)
Goal: (Equiv.sigmaEquivProd α β) a = (a.fst, a.snd)
-- Equiv.sigmaEquivProd_symm_apply
@[simps (config := { attrs := [`mfld_simps] }) apply symm_apply]
def sigmaEquivProd (α β : Type*) : (Σ _ : α, β) ≃ α × β 
Arguments: (α : Type u_1) (β : Type u_2) (a : α × β)
Goal: (Equiv.sigmaEquivProd α β).symm a = ⟨a.fst, a.snd⟩
-- Equiv.forall_congr_right
protected lemma forall_congr_right : (∀ a, q (e a)) ↔ ∀ b, q b 
Arguments: {α : Sort u} {β : Sort v} {q : β → Prop} (e : α ≃ β)
Goal: (∀ (a : α), q (e a)) ↔ ∀ (b : β), q b
-- Equiv.forall_congr_left
protected lemma forall_congr_left : (∀ a, p a) ↔ ∀ b, p (e.symm b) 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} (e : α ≃ β)
Goal: (∀ (a : α), p a) ↔ ∀ (b : β), p (e.symm b)
-- Equiv.forall_congr
protected lemma forall_congr (h : ∀ a, p a ↔ q (e a)) : (∀ a, p a) ↔ ∀ b, q b 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a))
Goal: (∀ (a : α), p a) ↔ ∀ (b : β), q b
-- Equiv.forall_congr'
protected lemma forall_congr' (h : ∀ b, p (e.symm b) ↔ q b) : (∀ a, p a) ↔ ∀ b, q b 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (b : β), p (e.symm b) ↔ q b)
Goal: (∀ (a : α), p a) ↔ ∀ (b : β), q b
-- Equiv.exists_congr_right
protected lemma exists_congr_right : (∃ a, q (e a)) ↔ ∃ b, q b 
Arguments: {α : Sort u} {β : Sort v} {q : β → Prop} (e : α ≃ β)
Goal: (∃ a, q (e a)) ↔ ∃ b, q b
-- Equiv.exists_congr_left
protected lemma exists_congr_left : (∃ a, p a) ↔ ∃ b, p (e.symm b) 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} (e : α ≃ β)
Goal: (∃ a, p a) ↔ ∃ b, p (e.symm b)
-- Equiv.exists_congr
protected lemma exists_congr (h : ∀ a, p a ↔ q (e a)) : (∃ a, p a) ↔ ∃ b, q b 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a))
Goal: (∃ a, p a) ↔ ∃ b, q b
-- Equiv.exists_congr'
protected lemma exists_congr' (h : ∀ b, p (e.symm b) ↔ q b) : (∃ a, p a) ↔ ∃ b, q b 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (b : β), p (e.symm b) ↔ q b)
Goal: (∃ a, p a) ↔ ∃ b, q b
-- Equiv.existsUnique_congr_right
protected lemma existsUnique_congr_right : (∃! a, q (e a)) ↔ ∃! b, q b 
Arguments: {α : Sort u} {β : Sort v} {q : β → Prop} (e : α ≃ β)
Goal: (∃! a, q (e a)) ↔ ∃! b, q b
-- Equiv.existsUnique_congr_left
protected lemma existsUnique_congr_left : (∃! a, p a) ↔ ∃! b, p (e.symm b) 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} (e : α ≃ β)
Goal: (∃! a, p a) ↔ ∃! b, p (e.symm b)
-- Equiv.existsUnique_congr
protected lemma existsUnique_congr (h : ∀ a, p a ↔ q (e a)) : (∃! a, p a) ↔ ∃! b, q b 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (a : α), p a ↔ q (e a))
Goal: (∃! a, p a) ↔ ∃! b, q b
-- Equiv.existsUnique_congr'
protected lemma existsUnique_congr' (h : ∀ b, p (e.symm b) ↔ q b) : (∃! a, p a) ↔ ∃! b, q b 
Arguments: {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β) (h : ∀ (b : β), p (e.symm b) ↔ q b)
Goal: (∃! a, p a) ↔ ∃! b, q b
-- Equiv.forall₂_congr
protected theorem forall₂_congr {α₁ α₂ β₁ β₂ : Sort*} {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop}
    (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p x y ↔ q (eα x) (eβ y)) :
    (∀ x y, p x y) ↔ ∀ x y, q x y 
Arguments: {α₁ : Sort u_1} {α₂ : Sort u_2} {β₁ : Sort u_3} {β₂ : Sort u_4} {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (h : ∀ {x : α₁} {y : β₁}, p x y ↔ q (eα x) (eβ y))
Goal: (∀ (x : α₁) (y : β₁), p x y) ↔ ∀ (x : α₂) (y : β₂), q x y
-- Equiv.forall₂_congr'
protected theorem forall₂_congr' {α₁ α₂ β₁ β₂ : Sort*} {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop}
    (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (h : ∀ {x y}, p (eα.symm x) (eβ.symm y) ↔ q x y) :
    (∀ x y, p x y) ↔ ∀ x y, q x y 
Arguments: {α₁ : Sort u_1} {α₂ : Sort u_2} {β₁ : Sort u_3} {β₂ : Sort u_4} {p : α₁ → β₁ → Prop} {q : α₂ → β₂ → Prop} (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (h : ∀ {x : α₂} {y : β₂}, p (eα.symm x) (eβ.symm y) ↔ q x y)
Goal: (∀ (x : α₁) (y : β₁), p x y) ↔ ∀ (x : α₂) (y : β₂), q x y
-- Equiv.forall₃_congr
protected theorem forall₃_congr
    {α₁ α₂ β₁ β₂ γ₁ γ₂ : Sort*} {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
    (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x y z}, p x y z ↔ q (eα x) (eβ y) (eγ z)) :
    (∀ x y z, p x y z) ↔ ∀ x y z, q x y z 
Arguments: {α₁ : Sort u_1} {α₂ : Sort u_2} {β₁ : Sort u_3} {β₂ : Sort u_4} {γ₁ : Sort u_5} {γ₂ : Sort u_6} {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x : α₁} {y : β₁} {z : γ₁}, p x y z ↔ q (eα x) (eβ y) (eγ z))
Goal: (∀ (x : α₁) (y : β₁) (z : γ₁), p x y z) ↔ ∀ (x : α₂) (y : β₂) (z : γ₂), q x y z
-- Equiv.forall₃_congr'
protected theorem forall₃_congr'
    {α₁ α₂ β₁ β₂ γ₁ γ₂ : Sort*} {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop}
    (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂)
    (h : ∀ {x y z}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z) :
    (∀ x y z, p x y z) ↔ ∀ x y z, q x y z 
Arguments: {α₁ : Sort u_1} {α₂ : Sort u_2} {β₁ : Sort u_3} {β₂ : Sort u_4} {γ₁ : Sort u_5} {γ₂ : Sort u_6} {p : α₁ → β₁ → γ₁ → Prop} {q : α₂ → β₂ → γ₂ → Prop} (eα : α₁ ≃ α₂) (eβ : β₁ ≃ β₂) (eγ : γ₁ ≃ γ₂) (h : ∀ {x : α₂} {y : β₂} {z : γ₂}, p (eα.symm x) (eβ.symm y) (eγ.symm z) ↔ q x y z)
Goal: (∀ (x : α₁) (y : β₁) (z : γ₁), p x y z) ↔ ∀ (x : α₂) (y : β₂) (z : γ₂), q x y z
-- Equiv.ofBijective_apply
@[simps apply]
noncomputable def ofBijective (f : α → β) (hf : Bijective f) : α ≃ β 
Arguments: {α : Sort u} {β : Sort v} (f : α → β) (hf : Function.Bijective f)
Goal: ∀ (a : α), (Equiv.ofBijective f hf) a = f a
-- Equiv.ofBijective_apply_symm_apply
lemma ofBijective_apply_symm_apply (f : α → β) (hf : Bijective f) (x : β) :
    f ((ofBijective f hf).symm x) = x 
Arguments: {α : Sort u} {β : Sort v} (f : α → β) (hf : Function.Bijective f) (x : β)
Goal: f ((Equiv.ofBijective f hf).symm x) = x
-- Equiv.ofBijective_symm_apply_apply
@[simp]
lemma ofBijective_symm_apply_apply (f : α → β) (hf : Bijective f) (x : α) :
    (ofBijective f hf).symm (f x) = x 
Arguments: {α : Sort u} {β : Sort v} (f : α → β) (hf : Function.Bijective f) (x : α)
Goal: (Equiv.ofBijective f hf).symm (f x) = x
-- Quot.congr_mk
@[simp] theorem congr_mk {ra : α → α → Prop} {rb : β → β → Prop} (e : α ≃ β)
    (eq : ∀ a₁ a₂ : α, ra a₁ a₂ ↔ rb (e a₁) (e a₂)) (a : α) :
    Quot.congr e eq (Quot.mk ra a) = Quot.mk rb (e a) 
Arguments: {α : Sort u} {β : Sort v} {ra : α → α → Prop} {rb : β → β → Prop} (e : α ≃ β) (eq : ∀ (a₁ a₂ : α), ra a₁ a₂ ↔ rb (e a₁) (e a₂)) (a : α)
Goal: (Quot.congr e eq) (Quot.mk ra a) = Quot.mk rb (e a)
-- Quotient.congr_mk
@[simp] theorem congr_mk {ra : Setoid α} {rb : Setoid β} (e : α ≃ β)
    (eq : ∀ a₁ a₂ : α, Setoid.r a₁ a₂ ↔ Setoid.r (e a₁) (e a₂)) (a : α) :
    Quotient.congr e eq (Quotient.mk ra a) = Quotient.mk rb (e a) 
Arguments: {α : Sort u} {β : Sort v} {ra : Setoid α} {rb : Setoid β} (e : α ≃ β) (eq : ∀ (a₁ a₂ : α), Setoid.r a₁ a₂ ↔ Setoid.r (e a₁) (e a₂)) (a : α)
Goal: (Quotient.congr e eq) ⟦a⟧ = ⟦e a⟧
-- Encodable.encode_list_nil
@[simp]
theorem encode_list_nil : encode (@nil α) = 0 
Arguments: {α : Type u_1} [Encodable α]
Goal: Encodable.encode [] = 0
-- Encodable.encode_list_cons
@[simp]
theorem encode_list_cons (a : α) (l : List α) :
    encode (a :: l) = succ (pair (encode a) (encode l)) 
Arguments: {α : Type u_1} [Encodable α] (a : α) (l : List α)
Goal: Encodable.encode (a :: l) = (Nat.pair (Encodable.encode a) (Encodable.encode l)).succ
-- Encodable.decode_list_zero
@[simp]
theorem decode_list_zero : decode (α := List α) 0 = some [] 
Arguments: {α : Type u_1} [Encodable α]
Goal: Encodable.decode 0 = some []
-- Encodable.decode_list_succ
@[simp, nolint unusedHavesSuffices] -- Porting note: false positive
theorem decode_list_succ (v : ℕ) :
    decode (α := List α) (succ v) =
      (· :: ·) <$> decode (α := α) v.unpair.1 <*> decode (α := List α) v.unpair.2 
Arguments: {α : Type u_1} [Encodable α] (v : ℕ)
Goal: Encodable.decode v.succ =
  Seq.seq ((fun x x_1 => x :: x_1) <$> Encodable.decode (Nat.unpair v).1) fun x => Encodable.decode (Nat.unpair v).2
-- Encodable.length_le_encode
theorem length_le_encode : ∀ l : List α, length l ≤ encode l
  
Arguments: {α : Type u_1} [Encodable α] (l : List α)
Goal: l.length ≤ Encodable.encode l
-- _private.Mathlib.Logic.Equiv.List.0.Encodable.enle.isLinearOrder
private theorem enle.isLinearOrder : IsLinearOrder α enle 
Arguments: {α : Type u_1} [Encodable α]
Goal: IsLinearOrder α Encodable.enle
-- Encodable.mem_sortedUniv
@[simp]
theorem mem_sortedUniv {α} [Fintype α] [Encodable α] (x : α) : x ∈ sortedUniv α 
Arguments: {α : Type u_2} [Fintype α] [Encodable α] (x : α)
Goal: x ∈ Encodable.sortedUniv α
-- Encodable.length_sortedUniv
@[simp]
theorem length_sortedUniv (α) [Fintype α] [Encodable α] : (sortedUniv α).length = Fintype.card α 
Arguments: (α : Type u_2) [Fintype α] [Encodable α]
Goal: (Encodable.sortedUniv α).length = Fintype.card α
-- Encodable.sortedUniv_nodup
@[simp]
theorem sortedUniv_nodup (α) [Fintype α] [Encodable α] : (sortedUniv α).Nodup 
Arguments: (α : Type u_2) [Fintype α] [Encodable α]
Goal: (Encodable.sortedUniv α).Nodup
-- Encodable.sortedUniv_toFinset
@[simp]
theorem sortedUniv_toFinset (α) [Fintype α] [Encodable α] [DecidableEq α] :
    (sortedUniv α).toFinset = Finset.univ 
Arguments: (α : Type u_2) [Fintype α] [Encodable α] [DecidableEq α]
Goal: (Encodable.sortedUniv α).toFinset = Finset.univ
-- Denumerable.denumerable_list_aux
@[nolint unusedHavesSuffices] -- Porting note: false positive
theorem denumerable_list_aux : ∀ n : ℕ, ∃ a ∈ @decodeList α _ n, encodeList a = n
  
Arguments: {α : Type u_1} [Denumerable α] (n : ℕ)
Goal: ∃ a ∈ Encodable.decodeList n, Encodable.encodeList a = n
-- Denumerable.list_ofNat_zero
@[simp]
theorem list_ofNat_zero : ofNat (List α) 0 = [] 
Arguments: {α : Type u_1} [Denumerable α]
Goal: Denumerable.ofNat (List α) 0 = []
-- Denumerable.list_ofNat_succ
@[simp, nolint unusedHavesSuffices] -- Porting note: false positive
theorem list_ofNat_succ (v : ℕ) :
    ofNat (List α) (succ v) = ofNat α v.unpair.1 :: ofNat (List α) v.unpair.2 
Arguments: {α : Type u_1} [Denumerable α] (v : ℕ)
Goal: Denumerable.ofNat (List α) v.succ = Denumerable.ofNat α (Nat.unpair v).1 :: Denumerable.ofNat (List α) (Nat.unpair v).2
-- Denumerable.lower_raise
theorem lower_raise : ∀ l n, lower (raise l n) n = l
  
Arguments: (l : List ℕ) (n : ℕ)
Goal: Denumerable.lower (Denumerable.raise l n) n = l
-- Denumerable.raise_lower
theorem raise_lower : ∀ {l n}, List.Sorted (· ≤ ·) (n :: l) → raise (lower l n) n = l
  
Arguments: {l : List ℕ} {n : ℕ}
Goal: List.Sorted (fun x x_1 => x ≤ x_1) (n :: l) → Denumerable.raise (Denumerable.lower l n) n = l
-- Denumerable.raise_chain
theorem raise_chain : ∀ l n, List.Chain (· ≤ ·) n (raise l n)
  
Arguments: (l : List ℕ) (n : ℕ)
Goal: List.Chain (fun x x_1 => x ≤ x_1) n (Denumerable.raise l n)
-- Denumerable.raise_sorted
theorem raise_sorted : ∀ l n, List.Sorted (· ≤ ·) (raise l n)
  
Arguments: (l : List ℕ) (n : ℕ)
Goal: List.Sorted (fun x x_1 => x ≤ x_1) (Denumerable.raise l n)
-- Denumerable.lower_raise'
theorem lower_raise' : ∀ l n, lower' (raise' l n) n = l
  
Arguments: (l : List ℕ) (n : ℕ)
Goal: Denumerable.lower' (Denumerable.raise' l n) n = l
-- Denumerable.raise_lower'
theorem raise_lower' : ∀ {l n}, (∀ m ∈ l, n ≤ m) → List.Sorted (· < ·) l → raise' (lower' l n) n = l
  
Arguments: {l : List ℕ} {n : ℕ}
Goal: (∀ m ∈ l, n ≤ m) → List.Sorted (fun x x_1 => x < x_1) l → Denumerable.raise' (Denumerable.lower' l n) n = l
-- Denumerable.raise'_chain
theorem raise'_chain : ∀ (l) {m n}, m < n → List.Chain (· < ·) m (raise' l n)
  
Arguments: (l : List ℕ) {m n : ℕ}
Goal: m < n → List.Chain (fun x x_1 => x < x_1) m (Denumerable.raise' l n)
-- Denumerable.raise'_sorted
theorem raise'_sorted : ∀ l n, List.Sorted (· < ·) (raise' l n)
  
Arguments: (l : List ℕ) (n : ℕ)
Goal: List.Sorted (fun x x_1 => x < x_1) (Denumerable.raise' l n)
-- piFinTwoEquiv_apply
@[simps (config := .asFn)]
def piFinTwoEquiv (α : Fin 2 → Type u) : (∀ i, α i) ≃ α 0 × α 1 
Arguments: (α : Fin 2 → Type u)
Goal: ⇑(piFinTwoEquiv α) = fun f => (f 0, f 1)
-- piFinTwoEquiv_symm_apply
@[simps (config := .asFn)]
def piFinTwoEquiv (α : Fin 2 → Type u) : (∀ i, α i) ≃ α 0 × α 1 
Arguments: (α : Fin 2 → Type u)
Goal: ⇑(piFinTwoEquiv α).symm = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)
-- Fin.preimage_apply_01_prod
theorem Fin.preimage_apply_01_prod {α : Fin 2 → Type u} (s : Set (α 0)) (t : Set (α 1)) :
    (fun f : ∀ i, α i => (f 0, f 1)) ⁻¹' s ×ˢ t =
      Set.pi Set.univ (Fin.cons s <| Fin.cons t finZeroElim) 
Arguments: {α : Fin 2 → Type u} (s : Set (α 0)) (t : Set (α 1))
Goal: (fun f => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.univ.pi (Fin.cons s (Fin.cons t finZeroElim))
-- Fin.preimage_apply_01_prod'
theorem Fin.preimage_apply_01_prod' {α : Type u} (s t : Set α) :
    (fun f : Fin 2 → α => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.pi Set.univ ![s, t] 
Arguments: {α : Type u} (s t : Set α)
Goal: (fun f => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.univ.pi ![s, t]
-- prodEquivPiFinTwo_symm_apply
@[simps! (config := .asFn)]
def prodEquivPiFinTwo (α β : Type u) : α × β ≃ ∀ i : Fin 2, ![α, β] i 
Arguments: (α β : Type u)
Goal: ⇑(prodEquivPiFinTwo α β).symm = fun f => (f 0, f 1)
-- prodEquivPiFinTwo_apply
@[simps! (config := .asFn)]
def prodEquivPiFinTwo (α β : Type u) : α × β ≃ ∀ i : Fin 2, ![α, β] i 
Arguments: (α β : Type u)
Goal: ⇑(prodEquivPiFinTwo α β) = fun p => Fin.cons p.1 (Fin.cons p.2 finZeroElim)
-- finTwoArrowEquiv_apply
@[simps (config := .asFn)]
def finTwoArrowEquiv (α : Type*) : (Fin 2 → α) ≃ α × α 
Arguments: (α : Type u_1)
Goal: ⇑(finTwoArrowEquiv α) = (piFinTwoEquiv fun x => α).toFun
-- finTwoArrowEquiv_symm_apply
@[simps (config := .asFn)]
def finTwoArrowEquiv (α : Type*) : (Fin 2 → α) ≃ α × α 
Arguments: (α : Type u_1)
Goal: ⇑(finTwoArrowEquiv α).symm = fun x => ![x.1, x.2]
-- finSuccEquiv'_at
@[simp]
theorem finSuccEquiv'_at (i : Fin (n + 1)) : (finSuccEquiv' i) i = none 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: (finSuccEquiv' i) i = none
-- finSuccEquiv'_succAbove
@[simp]
theorem finSuccEquiv'_succAbove (i : Fin (n + 1)) (j : Fin n) :
    finSuccEquiv' i (i.succAbove j) = some j 
Arguments: {n : ℕ} (i : Fin (n + 1)) (j : Fin n)
Goal: (finSuccEquiv' i) (i.succAbove j) = some j
-- finSuccEquiv'_below
theorem finSuccEquiv'_below {i : Fin (n + 1)} {m : Fin n} (h : Fin.castSucc m < i) :
    (finSuccEquiv' i) (Fin.castSucc m) = m 
Arguments: {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : m.castSucc < i)
Goal: (finSuccEquiv' i) m.castSucc = some m
-- finSuccEquiv'_above
theorem finSuccEquiv'_above {i : Fin (n + 1)} {m : Fin n} (h : i ≤ Fin.castSucc m) :
    (finSuccEquiv' i) m.succ = some m 
Arguments: {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : i ≤ m.castSucc)
Goal: (finSuccEquiv' i) m.succ = some m
-- finSuccEquiv'_symm_none
@[simp]
theorem finSuccEquiv'_symm_none (i : Fin (n + 1)) : (finSuccEquiv' i).symm none = i 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: (finSuccEquiv' i).symm none = i
-- finSuccEquiv'_symm_some
@[simp]
theorem finSuccEquiv'_symm_some (i : Fin (n + 1)) (j : Fin n) :
    (finSuccEquiv' i).symm (some j) = i.succAbove j 
Arguments: {n : ℕ} (i : Fin (n + 1)) (j : Fin n)
Goal: (finSuccEquiv' i).symm (some j) = i.succAbove j
-- finSuccEquiv'_symm_some_below
theorem finSuccEquiv'_symm_some_below {i : Fin (n + 1)} {m : Fin n} (h : Fin.castSucc m < i) :
    (finSuccEquiv' i).symm (some m) = Fin.castSucc m 
Arguments: {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : m.castSucc < i)
Goal: (finSuccEquiv' i).symm (some m) = m.castSucc
-- finSuccEquiv'_symm_some_above
theorem finSuccEquiv'_symm_some_above {i : Fin (n + 1)} {m : Fin n} (h : i ≤ Fin.castSucc m) :
    (finSuccEquiv' i).symm (some m) = m.succ 
Arguments: {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : i ≤ m.castSucc)
Goal: (finSuccEquiv' i).symm (some m) = m.succ
-- finSuccEquiv'_symm_coe_below
theorem finSuccEquiv'_symm_coe_below {i : Fin (n + 1)} {m : Fin n} (h : Fin.castSucc m < i) :
    (finSuccEquiv' i).symm m = Fin.castSucc m 
Arguments: {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : m.castSucc < i)
Goal: (finSuccEquiv' i).symm (some m) = m.castSucc
-- finSuccEquiv'_symm_coe_above
theorem finSuccEquiv'_symm_coe_above {i : Fin (n + 1)} {m : Fin n} (h : i ≤ Fin.castSucc m) :
    (finSuccEquiv' i).symm m = m.succ 
Arguments: {n : ℕ} {i : Fin (n + 1)} {m : Fin n} (h : i ≤ m.castSucc)
Goal: (finSuccEquiv' i).symm (some m) = m.succ
-- finSuccEquiv_zero
@[simp]
theorem finSuccEquiv_zero : (finSuccEquiv n) 0 = none 
Arguments: {n : ℕ}
Goal: (finSuccEquiv n) 0 = none
-- finSuccEquiv_succ
@[simp]
theorem finSuccEquiv_succ (m : Fin n) : (finSuccEquiv n) m.succ = some m 
Arguments: {n : ℕ} (m : Fin n)
Goal: (finSuccEquiv n) m.succ = some m
-- finSuccEquiv_symm_none
@[simp]
theorem finSuccEquiv_symm_none : (finSuccEquiv n).symm none = 0 
Arguments: {n : ℕ}
Goal: (finSuccEquiv n).symm none = 0
-- finSuccEquiv_symm_some
@[simp]
theorem finSuccEquiv_symm_some (m : Fin n) : (finSuccEquiv n).symm (some m) = m.succ 
Arguments: {n : ℕ} (m : Fin n)
Goal: (finSuccEquiv n).symm (some m) = m.succ
-- finSuccEquiv'_zero
theorem finSuccEquiv'_zero : finSuccEquiv' (0 : Fin (n + 1)) = finSuccEquiv n 
Arguments: {n : ℕ}
Goal: finSuccEquiv' 0 = finSuccEquiv n
-- finSuccEquiv'_last_apply_castSucc
theorem finSuccEquiv'_last_apply_castSucc (i : Fin n) :
    finSuccEquiv' (Fin.last n) (Fin.castSucc i) = i 
Arguments: {n : ℕ} (i : Fin n)
Goal: (finSuccEquiv' (Fin.last n)) i.castSucc = some i
-- finSuccEquiv'_last_apply
theorem finSuccEquiv'_last_apply {i : Fin (n + 1)} (h : i ≠ Fin.last n) :
    finSuccEquiv' (Fin.last n) i = Fin.castLT i (Fin.val_lt_last h) 
Arguments: {n : ℕ} {i : Fin (n + 1)} (h : i ≠ Fin.last n)
Goal: (finSuccEquiv' (Fin.last n)) i = some (i.castLT ⋯)
-- finSuccEquiv'_ne_last_apply
theorem finSuccEquiv'_ne_last_apply {i j : Fin (n + 1)} (hi : i ≠ Fin.last n) (hj : j ≠ i) :
    finSuccEquiv' i j = (i.castLT (Fin.val_lt_last hi)).predAbove j 
Arguments: {n : ℕ} {i j : Fin (n + 1)} (hi : i ≠ Fin.last n) (hj : j ≠ i)
Goal: (finSuccEquiv' i) j = some ((i.castLT ⋯).predAbove j)
-- finSuccAboveEquiv_apply
theorem finSuccAboveEquiv_apply (p : Fin (n + 1)) (i : Fin n) :
    finSuccAboveEquiv p i = ⟨p.succAbove i, p.succAbove_ne i⟩ 
Arguments: {n : ℕ} (p : Fin (n + 1)) (i : Fin n)
Goal: (finSuccAboveEquiv p) i = ⟨p.succAbove i, ⋯⟩
-- finSuccAboveEquiv_symm_apply_last
theorem finSuccAboveEquiv_symm_apply_last (x : { x : Fin (n + 1) // x ≠ Fin.last n }) :
    (finSuccAboveEquiv (Fin.last n)).symm x = Fin.castLT x.1 (Fin.val_lt_last x.2) 
Arguments: {n : ℕ} (x : { x // x ≠ Fin.last n })
Goal: (finSuccAboveEquiv (Fin.last n)).symm x = (↑x).castLT ⋯
-- finSuccAboveEquiv_symm_apply_ne_last
theorem finSuccAboveEquiv_symm_apply_ne_last {p : Fin (n + 1)} (h : p ≠ Fin.last n)
    (x : { x : Fin (n + 1) // x ≠ p }) :
    (finSuccAboveEquiv p).symm x = (p.castLT (Fin.val_lt_last h)).predAbove x 
Arguments: {n : ℕ} {p : Fin (n + 1)} (h : p ≠ Fin.last n) (x : { x // x ≠ p })
Goal: (finSuccAboveEquiv p).symm x = (p.castLT ⋯).predAbove ↑x
-- finSuccEquivLast_castSucc
@[simp]
theorem finSuccEquivLast_castSucc (i : Fin n) : finSuccEquivLast (Fin.castSucc i) = some i 
Arguments: {n : ℕ} (i : Fin n)
Goal: finSuccEquivLast i.castSucc = some i
-- finSuccEquivLast_last
@[simp]
theorem finSuccEquivLast_last : finSuccEquivLast (Fin.last n) = none 
Arguments: {n : ℕ}
Goal: finSuccEquivLast (Fin.last n) = none
-- finSuccEquivLast_symm_some
@[simp]
theorem finSuccEquivLast_symm_some (i : Fin n) :
    finSuccEquivLast.symm (some i) = Fin.castSucc i 
Arguments: {n : ℕ} (i : Fin n)
Goal: finSuccEquivLast.symm (some i) = i.castSucc
-- finSuccEquivLast_symm_none
@[simp] theorem finSuccEquivLast_symm_none : finSuccEquivLast.symm none = Fin.last n 
Arguments: {n : ℕ}
Goal: finSuccEquivLast.symm none = Fin.last n
-- Equiv.piFinSuccAbove_symm_apply
@[simps (config := .asFn)]
def Equiv.piFinSuccAbove (α : Fin (n + 1) → Type u) (i : Fin (n + 1)) :
    (∀ j, α j) ≃ α i × ∀ j, α (i.succAbove j) 
Arguments: {n : ℕ} (α : Fin (n + 1) → Type u) (i : Fin (n + 1))
Goal: ⇑(Equiv.piFinSuccAbove α i).symm = fun f => i.insertNth f.1 f.2
-- Equiv.piFinSuccAbove_apply
@[simps (config := .asFn)]
def Equiv.piFinSuccAbove (α : Fin (n + 1) → Type u) (i : Fin (n + 1)) :
    (∀ j, α j) ≃ α i × ∀ j, α (i.succAbove j) 
Arguments: {n : ℕ} (α : Fin (n + 1) → Type u) (i : Fin (n + 1))
Goal: ⇑(Equiv.piFinSuccAbove α i) = fun f => (f i, i.removeNth f)
-- Equiv.piFinSucc_symm_apply
@[simps! (config := .asFn)]
def Equiv.piFinSucc (n : ℕ) (β : Type u) : (Fin (n + 1) → β) ≃ β × (Fin n → β) 
Arguments: (n : ℕ) (β : Type u)
Goal: ⇑(Equiv.piFinSucc n β).symm = fun f => Fin.cons f.1 f.2
-- Equiv.piFinSucc_apply
@[simps! (config := .asFn)]
def Equiv.piFinSucc (n : ℕ) (β : Type u) : (Fin (n + 1) → β) ≃ β × (Fin n → β) 
Arguments: (n : ℕ) (β : Type u)
Goal: ⇑(Equiv.piFinSucc n β) = fun f => (f 0, Fin.tail f)
-- Equiv.embeddingFinSucc_fst
@[simp] lemma Equiv.embeddingFinSucc_fst {n : ℕ} {ι : Type*} (e : Fin (n+1) ↪ ι) :
    ((Equiv.embeddingFinSucc n ι e).1 : Fin n → ι) = e ∘ Fin.succ 
Arguments: {n : ℕ} {ι : Type u_1} (e : Fin (n + 1) ↪ ι)
Goal: ⇑((Equiv.embeddingFinSucc n ι) e).fst = ⇑e ∘ Fin.succ
-- Equiv.embeddingFinSucc_snd
@[simp] lemma Equiv.embeddingFinSucc_snd {n : ℕ} {ι : Type*} (e : Fin (n+1) ↪ ι) :
    ((Equiv.embeddingFinSucc n ι e).2 : ι) = e 0 
Arguments: {n : ℕ} {ι : Type u_1} (e : Fin (n + 1) ↪ ι)
Goal: ↑((Equiv.embeddingFinSucc n ι) e).snd = e 0
-- Equiv.coe_embeddingFinSucc_symm
@[simp] lemma Equiv.coe_embeddingFinSucc_symm {n : ℕ} {ι : Type*}
    (f : Σ (e : Fin n ↪ ι), {i // i ∉ Set.range e}) :
    ((Equiv.embeddingFinSucc n ι).symm f : Fin (n + 1) → ι) = Fin.cons f.2.1 f.1 
Arguments: {n : ℕ} {ι : Type u_1} (f : (e : Fin n ↪ ι) × { i // i ∉ Set.range ⇑e })
Goal: ⇑((Equiv.embeddingFinSucc n ι).symm f) = Fin.cons ↑f.snd ⇑f.fst
-- Equiv.piFinCastSucc_apply
@[simps! (config := .asFn)]
def Equiv.piFinCastSucc (n : ℕ) (β : Type u) : (Fin (n + 1) → β) ≃ β × (Fin n → β) 
Arguments: (n : ℕ) (β : Type u)
Goal: ⇑(Equiv.piFinCastSucc n β) = fun f => (f (Fin.last n), Fin.init f)