ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- Equiv.piFinCastSucc_symm_apply
@[simps! (config := .asFn)]
def Equiv.piFinCastSucc (n : ℕ) (β : Type u) : (Fin (n + 1) → β) ≃ β × (Fin n → β) 
Arguments: (n : ℕ) (β : Type u)
Goal: ⇑(Equiv.piFinCastSucc n β).symm = fun f => Fin.snoc f.2 f.1
-- finSumFinEquiv_apply_left
@[simp]
theorem finSumFinEquiv_apply_left (i : Fin m) :
    (finSumFinEquiv (Sum.inl i) : Fin (m + n)) = Fin.castAdd n i 
Arguments: {m n : ℕ} (i : Fin m)
Goal: finSumFinEquiv (Sum.inl i) = Fin.castAdd n i
-- finSumFinEquiv_apply_right
@[simp]
theorem finSumFinEquiv_apply_right (i : Fin n) :
    (finSumFinEquiv (Sum.inr i) : Fin (m + n)) = Fin.natAdd m i 
Arguments: {m n : ℕ} (i : Fin n)
Goal: finSumFinEquiv (Sum.inr i) = Fin.natAdd m i
-- finSumFinEquiv_symm_apply_castAdd
@[simp]
theorem finSumFinEquiv_symm_apply_castAdd (x : Fin m) :
    finSumFinEquiv.symm (Fin.castAdd n x) = Sum.inl x 
Arguments: {m n : ℕ} (x : Fin m)
Goal: finSumFinEquiv.symm (Fin.castAdd n x) = Sum.inl x
-- finSumFinEquiv_symm_apply_natAdd
@[simp]
theorem finSumFinEquiv_symm_apply_natAdd (x : Fin n) :
    finSumFinEquiv.symm (Fin.natAdd m x) = Sum.inr x 
Arguments: {m n : ℕ} (x : Fin n)
Goal: finSumFinEquiv.symm (Fin.natAdd m x) = Sum.inr x
-- finSumFinEquiv_symm_last
@[simp]
theorem finSumFinEquiv_symm_last : finSumFinEquiv.symm (Fin.last n) = Sum.inr 0 
Arguments: {n : ℕ}
Goal: finSumFinEquiv.symm (Fin.last n) = Sum.inr 0
-- finAddFlip_apply_castAdd
@[simp]
theorem finAddFlip_apply_castAdd (k : Fin m) (n : ℕ) :
    finAddFlip (Fin.castAdd n k) = Fin.natAdd n k 
Arguments: {m : ℕ} (k : Fin m) (n : ℕ)
Goal: finAddFlip (Fin.castAdd n k) = Fin.natAdd n k
-- finAddFlip_apply_natAdd
@[simp]
theorem finAddFlip_apply_natAdd (k : Fin n) (m : ℕ) :
    finAddFlip (Fin.natAdd m k) = Fin.castAdd m k 
Arguments: {n : ℕ} (k : Fin n) (m : ℕ)
Goal: finAddFlip (Fin.natAdd m k) = Fin.castAdd m k
-- finAddFlip_apply_mk_left
@[simp]
theorem finAddFlip_apply_mk_left {k : ℕ} (h : k < m) (hk : k < m + n := Nat.lt_add_right n h)
    (hnk : n + k < n + m := Nat.add_lt_add_left h n) :
    finAddFlip (⟨k, hk⟩ : Fin (m + n)) = ⟨n + k, hnk⟩ 
Arguments: {m n k : ℕ} (h : k < m) (hk : k < m + n := ⋯) (hnk : n + k < n + m := ⋯)
Goal: finAddFlip ⟨k, hk⟩ = ⟨n + k, hnk⟩
-- finAddFlip_apply_mk_right
@[simp]
theorem finAddFlip_apply_mk_right {k : ℕ} (h₁ : m ≤ k) (h₂ : k < m + n) :
    finAddFlip (⟨k, h₂⟩ : Fin (m + n)) = ⟨k - m, by omega⟩ 
Arguments: {m n k : ℕ} (h₁ : m ≤ k) (h₂ : k < m + n)
Goal: finAddFlip ⟨k, h₂⟩ = ⟨k - m, ⋯⟩
-- finRotate_zero
@[simp] lemma finRotate_zero : finRotate 0 = Equiv.refl _ 
Goal: finRotate 0 = Equiv.refl (Fin 0)
-- finRotate_succ
lemma finRotate_succ (n : ℕ) :
    finRotate (n + 1) = finAddFlip.trans (finCongr (Nat.add_comm 1 n)) 
Arguments: (n : ℕ)
Goal: finRotate (n + 1) = finAddFlip.trans (finCongr ⋯)
-- finRotate_of_lt
theorem finRotate_of_lt {k : ℕ} (h : k < n) :
    finRotate (n + 1) ⟨k, h.trans_le n.le_succ⟩ = ⟨k + 1, Nat.succ_lt_succ h⟩ 
Arguments: {n k : ℕ} (h : k < n)
Goal: (finRotate (n + 1)) ⟨k, ⋯⟩ = ⟨k + 1, ⋯⟩
-- finRotate_last'
theorem finRotate_last' : finRotate (n + 1) ⟨n, by omega⟩ = ⟨0, Nat.zero_lt_succ _⟩ 
Arguments: {n : ℕ}
Goal: (finRotate (n + 1)) ⟨n, ⋯⟩ = ⟨0, ⋯⟩
-- finRotate_last
theorem finRotate_last : finRotate (n + 1) (Fin.last _) = 0 
Arguments: {n : ℕ}
Goal: (finRotate (n + 1)) (Fin.last n) = 0
-- Fin.snoc_eq_cons_rotate
theorem Fin.snoc_eq_cons_rotate {α : Type*} (v : Fin n → α) (a : α) :
    @Fin.snoc _ (fun _ => α) v a = fun i => @Fin.cons _ (fun _ => α) a v (finRotate _ i) 
Arguments: {n : ℕ} {α : Type u_1} (v : Fin n → α) (a : α)
Goal: Fin.snoc v a = fun i => Fin.cons a v ((finRotate (n + 1)) i)
-- finRotate_one
@[simp]
theorem finRotate_one : finRotate 1 = Equiv.refl _ 
Goal: finRotate 1 = Equiv.refl (Fin 1)
-- finRotate_succ_apply
@[simp] theorem finRotate_succ_apply (i : Fin (n + 1)) : finRotate (n + 1) i = i + 1 
Arguments: {n : ℕ} (i : Fin (n + 1))
Goal: (finRotate (n + 1)) i = i + 1
-- finRotate_apply_zero
theorem finRotate_apply_zero : finRotate n.succ 0 = 1 
Arguments: {n : ℕ}
Goal: (finRotate n.succ) 0 = 1
-- coe_finRotate_of_ne_last
theorem coe_finRotate_of_ne_last {i : Fin n.succ} (h : i ≠ Fin.last n) :
    (finRotate (n + 1) i : ℕ) = i + 1 
Arguments: {n : ℕ} {i : Fin n.succ} (h : i ≠ Fin.last n)
Goal: ↑((finRotate (n + 1)) i) = ↑i + 1
-- coe_finRotate
theorem coe_finRotate (i : Fin n.succ) :
    (finRotate n.succ i : ℕ) = if i = Fin.last n then (0 : ℕ) else i + 1 
Arguments: {n : ℕ} (i : Fin n.succ)
Goal: ↑((finRotate n.succ) i) = if i = Fin.last n then 0 else ↑i + 1
-- finProdFinEquiv_symm_apply
@[simps]
def finProdFinEquiv : Fin m × Fin n ≃ Fin (m * n) 
Arguments: {m n : ℕ} (x : Fin (m * n))
Goal: finProdFinEquiv.symm x = (x.divNat, x.modNat)
-- finProdFinEquiv_apply_val
@[simps]
def finProdFinEquiv : Fin m × Fin n ≃ Fin (m * n) 
Arguments: {m n : ℕ} (x : Fin m × Fin n)
Goal: ↑(finProdFinEquiv x) = ↑x.2 + n * ↑x.1
-- Nat.divModEquiv_symm_apply
@[simps]
def Nat.divModEquiv (n : ℕ) [NeZero n] : ℕ ≃ ℕ × Fin n 
Arguments: (n : ℕ) [NeZero n] (p : ℕ × Fin n)
Goal: n.divModEquiv.symm p = p.1 * n + ↑p.2
-- Nat.divModEquiv_apply
@[simps]
def Nat.divModEquiv (n : ℕ) [NeZero n] : ℕ ≃ ℕ × Fin n 
Arguments: (n : ℕ) [NeZero n] (a : ℕ)
Goal: n.divModEquiv a = (a / n, ↑a)
-- Int.divModEquiv_apply
@[simps]
def Int.divModEquiv (n : ℕ) [NeZero n] : ℤ ≃ ℤ × Fin n 
Arguments: (n : ℕ) [NeZero n] (a : ℤ)
Goal: (Int.divModEquiv n) a = (a / ↑n, ↑(a.natMod ↑n))
-- Int.divModEquiv_symm_apply
@[simps]
def Int.divModEquiv (n : ℕ) [NeZero n] : ℤ ≃ ℤ × Fin n 
Arguments: (n : ℕ) [NeZero n] (p : ℤ × Fin n)
Goal: (Int.divModEquiv n).symm p = p.1 * ↑n + ↑↑p.2
-- Fin.castLEquiv_apply
@[simps apply symm_apply]
def Fin.castLEquiv {n m : ℕ} (h : n ≤ m) : Fin n ≃ { i : Fin m // (i : ℕ) < n } 
Arguments: {n m : ℕ} (h : n ≤ m) (i : Fin n)
Goal: (Fin.castLEquiv h) i = ⟨Fin.castLE h i, ⋯⟩
-- Fin.castLEquiv_symm_apply
@[simps apply symm_apply]
def Fin.castLEquiv {n m : ℕ} (h : n ≤ m) : Fin n ≃ { i : Fin m // (i : ℕ) < n } 
Arguments: {n m : ℕ} (h : n ≤ m) (i : { i // ↑i < n })
Goal: (Fin.castLEquiv h).symm i = ⟨↑↑i, ⋯⟩
-- Functor.mapEquiv_apply
@[simp]
theorem mapEquiv_apply (h : α ≃ β) (x : f α) : (mapEquiv f h : f α ≃ f β) x = map h x 
Arguments: {α β : Type u} (f : Type u → Type v) [Functor f] [LawfulFunctor f] (h : α ≃ β) (x : f α)
Goal: (Functor.mapEquiv f h) x = ⇑h <$> x
-- Functor.mapEquiv_symm_apply
@[simp]
theorem mapEquiv_symm_apply (h : α ≃ β) (y : f β) :
    (mapEquiv f h : f α ≃ f β).symm y = map h.symm y 
Arguments: {α β : Type u} (f : Type u → Type v) [Functor f] [LawfulFunctor f] (h : α ≃ β) (y : f β)
Goal: (Functor.mapEquiv f h).symm y = ⇑h.symm <$> y
-- Functor.mapEquiv_refl
@[simp]
theorem mapEquiv_refl : mapEquiv f (Equiv.refl α) = Equiv.refl (f α) 
Arguments: {α : Type u} (f : Type u → Type v) [Functor f] [LawfulFunctor f]
Goal: Functor.mapEquiv f (Equiv.refl α) = Equiv.refl (f α)
-- Bifunctor.mapEquiv_apply
@[simp]
theorem mapEquiv_apply (h : α ≃ β) (h' : α' ≃ β') (x : F α α') :
    (mapEquiv F h h' : F α α' ≃ F β β') x = bimap h h' x 
Arguments: {α β : Type u} {α' β' : Type v} (F : Type u → Type v → Type w) [Bifunctor F] [LawfulBifunctor F] (h : α ≃ β) (h' : α' ≃ β') (x : F α α')
Goal: (Bifunctor.mapEquiv F h h') x = bimap (⇑h) (⇑h') x
-- Bifunctor.mapEquiv_symm_apply
@[simp]
theorem mapEquiv_symm_apply (h : α ≃ β) (h' : α' ≃ β') (y : F β β') :
    (mapEquiv F h h' : F α α' ≃ F β β').symm y = bimap h.symm h'.symm y 
Arguments: {α β : Type u} {α' β' : Type v} (F : Type u → Type v → Type w) [Bifunctor F] [LawfulBifunctor F] (h : α ≃ β) (h' : α' ≃ β') (y : F β β')
Goal: (Bifunctor.mapEquiv F h h').symm y = bimap (⇑h.symm) (⇑h'.symm) y
-- Bifunctor.mapEquiv_refl_refl
@[simp]
theorem mapEquiv_refl_refl : mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α') 
Arguments: {α : Type u} {α' : Type v} (F : Type u → Type v → Type w) [Bifunctor F] [LawfulBifunctor F]
Goal: Bifunctor.mapEquiv F (Equiv.refl α) (Equiv.refl α') = Equiv.refl (F α α')
-- EmbeddingLike.pairwise_comp
lemma EmbeddingLike.pairwise_comp {X : Type*} {Y : Type*} {F} [FunLike F Y X] [EmbeddingLike F Y X]
    (f : F) {p : X → X → Prop} (h : Pairwise p) : Pairwise (p on f) 
Arguments: {X : Type u_1} {Y : Type u_2} {F : Sort u_3} [FunLike F Y X] [EmbeddingLike F Y X] (f : F) {p : X → X → Prop} (h : Pairwise p)
Goal: Pairwise (p on ⇑f)
-- EquivLike.pairwise_comp_iff
lemma EquivLike.pairwise_comp_iff {X : Type*} {Y : Type*} {F} [EquivLike F Y X]
    (f : F) (p : X → X → Prop) : Pairwise (p on f) ↔ Pairwise p 
Arguments: {X : Type u_1} {Y : Type u_2} {F : Sort u_3} [EquivLike F Y X] (f : F) (p : X → X → Prop)
Goal: Pairwise (p on ⇑f) ↔ Pairwise p
-- Function.ofArity_zero
@[simp]
theorem ofArity_zero (α β : Type u) : OfArity α β 0 = β 
Arguments: (α β : Type u)
Goal: Function.OfArity α β 0 = β
-- Function.ofArity_succ
@[simp]
theorem ofArity_succ (α β : Type u) (n : ℕ) :
    OfArity α β n.succ = (α → OfArity α β n) 
Arguments: (α β : Type u) (n : ℕ)
Goal: Function.OfArity α β n.succ = (α → Function.OfArity α β n)
-- Function.OfArity.const_zero
@[simp]
theorem const_zero (α : Type u) {β : Type u} (b : β) : const α b 0 = b 
Arguments: (α : Type u) {β : Type u} (b : β)
Goal: Function.OfArity.const α b 0 = b
-- Function.OfArity.const_succ
@[simp]
theorem const_succ (α : Type u) {β : Type u} (b : β) (n : ℕ) :
    const α b n.succ = fun _ => const _ b n 
Arguments: (α : Type u) {β : Type u} (b : β) (n : ℕ)
Goal: Function.OfArity.const α b n.succ = fun x => Function.OfArity.const α b n
-- Function.OfArity.const_succ_apply
theorem const_succ_apply (α : Type u) {β : Type u} (b : β) (n : ℕ) (x : α) :
    const α b n.succ x = const _ b n 
Arguments: (α : Type u) {β : Type u} (b : β) (n : ℕ) (x : α)
Goal: Function.OfArity.const α b n.succ x = Function.OfArity.const α b n
-- Function.FromTypes.fromTypes_fin_const
lemma fromTypes_fin_const (α β : Type u) (n : ℕ) :
    FromTypes (fun (_ : Fin n) => α) β = OfArity α β n 
Arguments: (α β : Type u) (n : ℕ)
Goal: Function.FromTypes (fun x => α) β = Function.OfArity α β n
-- Equiv.optionCongr_apply
@[simps apply]
def optionCongr (e : α ≃ β) : Option α ≃ Option β 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: ∀ (a : Option α), e.optionCongr a = Option.map (⇑e) a
-- Equiv.optionCongr_refl
@[simp]
theorem optionCongr_refl : optionCongr (Equiv.refl α) = Equiv.refl _ 
Arguments: {α : Type u_1}
Goal: (Equiv.refl α).optionCongr = Equiv.refl (Option α)
-- Equiv.optionCongr_symm
@[simp]
theorem optionCongr_symm (e : α ≃ β) : (optionCongr e).symm = optionCongr e.symm 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: e.optionCongr.symm = e.symm.optionCongr
-- Equiv.optionCongr_trans
@[simp]
theorem optionCongr_trans (e₁ : α ≃ β) (e₂ : β ≃ γ) :
    (optionCongr e₁).trans (optionCongr e₂) = optionCongr (e₁.trans e₂) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e₁ : α ≃ β) (e₂ : β ≃ γ)
Goal: e₁.optionCongr.trans e₂.optionCongr = (e₁.trans e₂).optionCongr
-- Equiv.optionCongr_eq_equivFunctor_mapEquiv
theorem optionCongr_eq_equivFunctor_mapEquiv {α β : Type u} (e : α ≃ β) :
    optionCongr e = EquivFunctor.mapEquiv Option e 
Arguments: {α β : Type u} (e : α ≃ β)
Goal: e.optionCongr = EquivFunctor.mapEquiv Option e
-- Equiv.removeNone_aux_some
theorem removeNone_aux_some {x : α} (h : ∃ x', e (some x) = some x') :
    some (removeNone_aux e x) = e (some x) 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α} (h : ∃ x', e (some x) = some x')
Goal: some (e.removeNone_aux x) = e (some x)
-- Equiv.removeNone_aux_none
theorem removeNone_aux_none {x : α} (h : e (some x) = none) :
    some (removeNone_aux e x) = e none 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α} (h : e (some x) = none)
Goal: some (e.removeNone_aux x) = e none
-- Equiv.removeNone_aux_inv
theorem removeNone_aux_inv (x : α) : removeNone_aux e.symm (removeNone_aux e x) = x 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) (x : α)
Goal: e.symm.removeNone_aux (e.removeNone_aux x) = x
-- Equiv.removeNone_symm
@[simp]
theorem removeNone_symm : (removeNone e).symm = removeNone e.symm 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β)
Goal: e.removeNone.symm = e.symm.removeNone
-- Equiv.removeNone_some
theorem removeNone_some {x : α} (h : ∃ x', e (some x) = some x') :
    some (removeNone e x) = e (some x) 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α} (h : ∃ x', e (some x) = some x')
Goal: some (e.removeNone x) = e (some x)
-- Equiv.removeNone_none
theorem removeNone_none {x : α} (h : e (some x) = none) : some (removeNone e x) = e none 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α} (h : e (some x) = none)
Goal: some (e.removeNone x) = e none
-- Equiv.option_symm_apply_none_iff
@[simp]
theorem option_symm_apply_none_iff : e.symm none = none ↔ e none = none 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β)
Goal: e.symm none = none ↔ e none = none
-- Equiv.some_removeNone_iff
theorem some_removeNone_iff {x : α} : some (removeNone e x) = e none ↔ e.symm none = some x 
Arguments: {α : Type u_1} {β : Type u_2} (e : Option α ≃ Option β) {x : α}
Goal: some (e.removeNone x) = e none ↔ e.symm none = some x
-- Equiv.removeNone_optionCongr
@[simp]
theorem removeNone_optionCongr (e : α ≃ β) : removeNone e.optionCongr = e 
Arguments: {α : Type u_1} {β : Type u_2} (e : α ≃ β)
Goal: e.optionCongr.removeNone = e
-- Equiv.optionCongr_injective
theorem optionCongr_injective : Function.Injective (optionCongr : α ≃ β → Option α ≃ Option β) 
Arguments: {α : Type u_1} {β : Type u_2}
Goal: Function.Injective Equiv.optionCongr
-- Equiv.optionSubtype_apply_apply
@[simp]
theorem optionSubtype_apply_apply
    [DecidableEq β] (x : β)
    (e : { e : Option α ≃ β // e none = x })
    (a : α)
    (h) : optionSubtype x e a = ⟨(e : Option α ≃ β) a, h⟩ 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (x : β) (e : { e // e none = x }) (a : α) (h : ↑e (some a) ≠ x)
Goal: ((Equiv.optionSubtype x) e) a = ⟨↑e (some a), h⟩
-- Equiv.coe_optionSubtype_apply_apply
@[simp]
theorem coe_optionSubtype_apply_apply
    [DecidableEq β] (x : β)
    (e : { e : Option α ≃ β // e none = x })
    (a : α) : ↑(optionSubtype x e a) = (e : Option α ≃ β) a 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (x : β) (e : { e // e none = x }) (a : α)
Goal: ↑(((Equiv.optionSubtype x) e) a) = ↑e (some a)
-- Equiv.optionSubtype_apply_symm_apply
@[simp]
theorem optionSubtype_apply_symm_apply
    [DecidableEq β] (x : β)
    (e : { e : Option α ≃ β // e none = x })
    (b : { y : β // y ≠ x }) : ↑((optionSubtype x e).symm b) = (e : Option α ≃ β).symm b 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (x : β) (e : { e // e none = x }) (b : { y // y ≠ x })
Goal: some (((Equiv.optionSubtype x) e).symm b) = (↑e).symm ↑b
-- Equiv.optionSubtype_symm_apply_apply_coe
@[simp]
theorem optionSubtype_symm_apply_apply_coe [DecidableEq β] (x : β) (e : α ≃ { y : β // y ≠ x })
    (a : α) : ((optionSubtype x).symm e : Option α ≃ β) a = e a 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (x : β) (e : α ≃ { y // y ≠ x }) (a : α)
Goal: ↑((Equiv.optionSubtype x).symm e) (some a) = ↑(e a)
-- Equiv.optionSubtype_symm_apply_apply_some
@[simp]
theorem optionSubtype_symm_apply_apply_some
    [DecidableEq β]
    (x : β)
    (e : α ≃ { y : β // y ≠ x })
    (a : α) : ((optionSubtype x).symm e : Option α ≃ β) (some a) = e a 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (x : β) (e : α ≃ { y // y ≠ x }) (a : α)
Goal: ↑((Equiv.optionSubtype x).symm e) (some a) = ↑(e a)
-- Equiv.optionSubtype_symm_apply_apply_none
@[simp]
theorem optionSubtype_symm_apply_apply_none
    [DecidableEq β]
    (x : β)
    (e : α ≃ { y : β // y ≠ x }) : ((optionSubtype x).symm e : Option α ≃ β) none = x 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (x : β) (e : α ≃ { y // y ≠ x })
Goal: ↑((Equiv.optionSubtype x).symm e) none = x
-- Equiv.optionSubtype_symm_apply_symm_apply
@[simp]
theorem optionSubtype_symm_apply_symm_apply [DecidableEq β] (x : β) (e : α ≃ { y : β // y ≠ x })
    (b : { y : β // y ≠ x }) : ((optionSubtype x).symm e : Option α ≃ β).symm b = e.symm b 
Arguments: {α : Type u_1} {β : Type u_2} [DecidableEq β] (x : β) (e : α ≃ { y // y ≠ x }) (b : { y // y ≠ x })
Goal: (↑((Equiv.optionSubtype x).symm e)).symm ↑b = some (e.symm b)
-- Equiv.optionSubtypeNe_apply
@[simps!]
def optionSubtypeNe (a : α) : Option {b // b ≠ a} ≃ α 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: ∀ (a_1 : Option { y // y ≠ a }), (Equiv.optionSubtypeNe a) a_1 = a_1.casesOn' a Subtype.val
-- Equiv.optionSubtypeNe_symm_apply
@[simps!]
def optionSubtypeNe (a : α) : Option {b // b ≠ a} ≃ α 
Arguments: {α : Type u_1} [DecidableEq α] (a b : α)
Goal: (Equiv.optionSubtypeNe a).symm b = if h : b = a then none else some ⟨b, h⟩
-- Equiv.optionSubtypeNe_symm_self
lemma optionSubtypeNe_symm_self (a : α) : (optionSubtypeNe a).symm a = none 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: (Equiv.optionSubtypeNe a).symm a = none
-- Equiv.optionSubtypeNe_symm_of_ne
lemma optionSubtypeNe_symm_of_ne (hba : b ≠ a) : (optionSubtypeNe a).symm b = some ⟨b, hba⟩ 
Arguments: {α : Type u_1} [DecidableEq α] {a b : α} (hba : b ≠ a)
Goal: (Equiv.optionSubtypeNe a).symm b = some ⟨b, hba⟩
-- Equiv.optionSubtypeNe_none
@[simp] lemma optionSubtypeNe_none (a : α) : optionSubtypeNe a none = a 
Arguments: {α : Type u_1} [DecidableEq α] (a : α)
Goal: (Equiv.optionSubtypeNe a) none = a
-- Equiv.optionSubtypeNe_some
@[simp] lemma optionSubtypeNe_some (a : α) (b) : optionSubtypeNe a (some b) = b 
Arguments: {α : Type u_1} [DecidableEq α] (a : α) (b : { b // b ≠ a })
Goal: (Equiv.optionSubtypeNe a) (some b) = ↑b
-- Function.fromTypes_zero
theorem fromTypes_zero (p : Fin 0 → Type u) (τ : Type u) : FromTypes p τ = τ 
Arguments: (p : Fin 0 → Type u) (τ : Type u)
Goal: Function.FromTypes p τ = τ
-- Function.fromTypes_nil
theorem fromTypes_nil (τ : Type u) : FromTypes ![] τ = τ 
Arguments: (τ : Type u)
Goal: Function.FromTypes ![] τ = τ
-- Function.fromTypes_succ
theorem fromTypes_succ {n} (p : Fin (n + 1) → Type u) (τ : Type u) :
    FromTypes p τ = (vecHead p → FromTypes (vecTail p) τ) 
Arguments: {n : ℕ} (p : Fin (n + 1) → Type u) (τ : Type u)
Goal: Function.FromTypes p τ = (Matrix.vecHead p → Function.FromTypes (Matrix.vecTail p) τ)
-- Function.fromTypes_cons
theorem fromTypes_cons {n} (α : Type u) (p : Fin n → Type u) (τ : Type u) :
    FromTypes (vecCons α p) τ = (α → FromTypes p τ) 
Arguments: {n : ℕ} (α : Type u) (p : Fin n → Type u) (τ : Type u)
Goal: Function.FromTypes (Matrix.vecCons α p) τ = (α → Function.FromTypes p τ)
-- Function.fromTypes_zero_equiv_apply
@[simps!]
def fromTypes_zero_equiv (p : Fin 0 → Type u) (τ : Type u) :
    FromTypes p τ ≃ τ 
Arguments: (p : Fin 0 → Type u) (τ : Type u) (a : Function.FromTypes p τ)
Goal: (Function.fromTypes_zero_equiv p τ) a = a
-- Function.fromTypes_zero_equiv_symm_apply
@[simps!]
def fromTypes_zero_equiv (p : Fin 0 → Type u) (τ : Type u) :
    FromTypes p τ ≃ τ 
Arguments: (p : Fin 0 → Type u) (τ : Type u) (a : Function.FromTypes p τ)
Goal: (Function.fromTypes_zero_equiv p τ).symm a = a
-- Function.fromTypes_nil_equiv_apply
@[simps!]
def fromTypes_nil_equiv (τ : Type u) : FromTypes ![] τ ≃ τ 
Arguments: (τ : Type u) (a : Function.FromTypes ![] τ)
Goal: (Function.fromTypes_nil_equiv τ) a = a
-- Function.fromTypes_nil_equiv_symm_apply
@[simps!]
def fromTypes_nil_equiv (τ : Type u) : FromTypes ![] τ ≃ τ 
Arguments: (τ : Type u) (a : Function.FromTypes ![] τ)
Goal: (Function.fromTypes_nil_equiv τ).symm a = a
-- Function.fromTypes_succ_equiv_apply
@[simps!]
def fromTypes_succ_equiv {n} (p : Fin (n + 1) → Type u) (τ : Type u) :
    FromTypes p τ ≃ (vecHead p → FromTypes (vecTail p) τ) 
Arguments: {n : ℕ} (p : Fin (n + 1) → Type u) (τ : Type u) (a : Function.FromTypes p τ)
Goal: (Function.fromTypes_succ_equiv p τ) a = a
-- Function.fromTypes_succ_equiv_symm_apply
@[simps!]
def fromTypes_succ_equiv {n} (p : Fin (n + 1) → Type u) (τ : Type u) :
    FromTypes p τ ≃ (vecHead p → FromTypes (vecTail p) τ) 
Arguments: {n : ℕ} (p : Fin (n + 1) → Type u) (τ : Type u) (a : Function.FromTypes p τ)
Goal: (Function.fromTypes_succ_equiv p τ).symm a = a
-- Function.fromTypes_cons_equiv_apply
@[simps!]
def fromTypes_cons_equiv {n} (α : Type u) (p : Fin n → Type u) (τ : Type u) :
    FromTypes (vecCons α p) τ ≃ (α → FromTypes p τ) 
Arguments: {n : ℕ} (α : Type u) (p : Fin n → Type u) (τ : Type u) (a : Function.FromTypes (Matrix.vecCons α p) τ)
Goal: (Function.fromTypes_cons_equiv α p τ) a = a
-- Function.fromTypes_cons_equiv_symm_apply
@[simps!]
def fromTypes_cons_equiv {n} (α : Type u) (p : Fin n → Type u) (τ : Type u) :
    FromTypes (vecCons α p) τ ≃ (α → FromTypes p τ) 
Arguments: {n : ℕ} (α : Type u) (p : Fin n → Type u) (τ : Type u) (a : Function.FromTypes (Matrix.vecCons α p) τ)
Goal: (Function.fromTypes_cons_equiv α p τ).symm a = a
-- Function.FromTypes.const_zero
@[simp]
theorem const_zero (p : Fin 0 → Type u) {τ : Type u} (t : τ) : const p t = t 
Arguments: (p : Fin 0 → Type u) {τ : Type u} (t : τ)
Goal: Function.FromTypes.const p t = t
-- Function.FromTypes.const_succ
@[simp]
theorem const_succ {n} (p : Fin (n + 1) → Type u) {τ : Type u} (t : τ) :
    const p t = fun _ => const (vecTail p) t 
Arguments: {n : ℕ} (p : Fin (n + 1) → Type u) {τ : Type u} (t : τ)
Goal: Function.FromTypes.const p t = fun x => Function.FromTypes.const (Matrix.vecTail p) t
-- Function.FromTypes.const_succ_apply
theorem const_succ_apply {n} (p : Fin (n + 1) → Type u) {τ : Type u} (t : τ)
    (x : p 0) : const p t x = const (vecTail p) t 
Arguments: {n : ℕ} (p : Fin (n + 1) → Type u) {τ : Type u} (t : τ) (x : p 0)
Goal: Function.FromTypes.const p t x = Function.FromTypes.const (Matrix.vecTail p) t
-- CompTriple.comp_eq
class CompTriple  {M N P : Type*} (φ : M → N) (ψ : N → P) (χ : outParam (M → P)) : Prop where
    comp_eq : ψ.comp φ = χ
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} {φ : M → N} {ψ : N → P} {χ : outParam (M → P)} [self : CompTriple φ ψ χ]
Goal: ψ ∘ φ = χ
-- CompTriple.IsId.eq_id
class IsId {M : Type*} (σ : M → M) : Prop where
  eq_id : σ = id
Arguments: {M : Type u_1} {σ : M → M} [self : CompTriple.IsId σ]
Goal: σ = id
-- CompTriple.comp
theorem comp {M N P : Type*}
    {φ : M → N} {ψ : N → P} :
    CompTriple φ ψ  (ψ.comp φ) 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} {φ : M → N} {ψ : N → P}
Goal: CompTriple φ ψ (ψ ∘ φ)
-- CompTriple.comp_inv
lemma comp_inv {M N : Type*} {φ : M → N} {ψ : N → M}
    (h : Function.RightInverse φ ψ) {χ : M → M} [IsId χ] :
    CompTriple φ ψ χ 
Arguments: {M : Type u_1} {N : Type u_2} {φ : M → N} {ψ : N → M} (h : Function.RightInverse φ ψ) {χ : M → M} [CompTriple.IsId χ]
Goal: CompTriple φ ψ χ
-- CompTriple.comp_apply
lemma comp_apply {M N P : Type*}
    {φ : M → N} {ψ : N → P} {χ : M → P} (h : CompTriple φ ψ χ) (x : M) :
    ψ (φ x) = χ x 
Arguments: {M : Type u_1} {N : Type u_2} {P : Type u_3} {φ : M → N} {ψ : N → P} {χ : M → P} (h : CompTriple φ ψ χ) (x : M)
Goal: ψ (φ x) = χ x
-- ULift.down_injective
theorem ULift.down_injective {α : Sort _} : Function.Injective (@ULift.down α)
  
Arguments: {α : Type u_1}
Goal: Function.Injective ULift.down
-- ULift.down_inj
@[simp] theorem ULift.down_inj {α : Sort _} {a b : ULift α} : a.down = b.down ↔ a = b 
Arguments: {α : Type u_1} {a b : ULift.{u_2, u_1} α}
Goal: a.down = b.down ↔ a = b
-- PLift.down_injective
theorem PLift.down_injective : Function.Injective (@PLift.down α)
  
Arguments: {α : Sort u_1}
Goal: Function.Injective PLift.down
-- PLift.down_inj
@[simp] theorem PLift.down_inj {a b : PLift α} : a.down = b.down ↔ a = b 
Arguments: {α : Sort u_1} {a b : PLift α}
Goal: a.down = b.down ↔ a = b
-- Function.flip_def
lemma flip_def {f : α → β → φ} : flip f = fun b a => f a b 
Arguments: {α : Sort u₁} {β : Sort u₂} {φ : Sort u₃} {f : α → β → φ}
Goal: flip f = fun b a => f a b
-- Function.swap_def
theorem swap_def {φ : α → β → Sort u₃} (f : ∀ x y, φ x y) : swap f = fun y x => f x y 
Arguments: {α : Sort u₁} {β : Sort u₂} {φ : α → β → Sort u₃} (f : (x : α) → (y : β) → φ x y)
Goal: Function.swap f = fun y x => f x y
-- Function.id_comp
@[simp, mfld_simps]
theorem id_comp (f : α → β) : id ∘ f = f 
Arguments: {α : Sort u₁} {β : Sort u₂} (f : α → β)
Goal: id ∘ f = f