ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddEquiv.toAddMonoidHom_eq_coe
@[to_additive (attr := simp)]
theorem toMonoidHom_eq_coe (f : M ≃* N) : f.toMonoidHom = (f : M →* N) 
Arguments: {M : Type u_6} {N : Type u_7} [AddZeroClass M] [AddZeroClass N] (f : M ≃+ N)
Goal: f.toAddMonoidHom = ↑f
-- MulEquiv.toMonoidHom_injective
@[to_additive]
theorem toMonoidHom_injective : Injective (toMonoidHom : M ≃* N → M →* N) 
Arguments: {M : Type u_6} {N : Type u_7} [MulOneClass M] [MulOneClass N]
Goal: Function.Injective MulEquiv.toMonoidHom
-- AddEquiv.toAddMonoidHom_injective
@[to_additive]
theorem toMonoidHom_injective : Injective (toMonoidHom : M ≃* N → M →* N) 
Arguments: {M : Type u_6} {N : Type u_7} [AddZeroClass M] [AddZeroClass N]
Goal: Function.Injective AddEquiv.toAddMonoidHom
-- MulEquiv.arrowCongr_apply
@[to_additive (attr := simps apply) "An additive analogue of `Equiv.arrowCongr`,
  where the equivalence between the targets is additive."]
def arrowCongr {M N P Q : Type*} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
    (M → P) ≃* (N → Q) 
Arguments: {M : Type u_12} {N : Type u_13} {P : Type u_14} {Q : Type u_15} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) (h : M → P) (n : N)
Goal: (MulEquiv.arrowCongr f g) h n = g (h (f.symm n))
-- AddEquiv.arrowCongr_apply
@[to_additive (attr := simps apply) "An additive analogue of `Equiv.arrowCongr`,
  where the equivalence between the targets is additive."]
def arrowCongr {M N P Q : Type*} [Mul P] [Mul Q] (f : M ≃ N) (g : P ≃* Q) :
    (M → P) ≃* (N → Q) 
Arguments: {M : Type u_12} {N : Type u_13} {P : Type u_14} {Q : Type u_15} [Add P] [Add Q] (f : M ≃ N) (g : P ≃+ Q) (h : M → P) (n : N)
Goal: (AddEquiv.arrowCongr f g) h n = g (h (f.symm n))
-- MulEquiv.monoidHomCongr_apply
@[to_additive (attr := simps apply)
  "An additive analogue of `Equiv.arrowCongr`,
  for additive maps from an additive monoid to a commutative additive monoid."]
-- Porting note: @[simps apply] removed because it was making a lemma which
-- wasn't in simp normal form.
def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q]
    (f : M ≃* N) (g : P ≃* Q) : (M →* P) ≃* (N →* Q) 
Arguments: {M : Type u_12} {N : Type u_13} {P : Type u_14} {Q : Type u_15} [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q] (f : M ≃* N) (g : P ≃* Q) (h : M →* P)
Goal: (f.monoidHomCongr g) h = g.toMonoidHom.comp (h.comp f.symm.toMonoidHom)
-- AddEquiv.addMonoidHomCongr_apply
@[to_additive (attr := simps apply)
  "An additive analogue of `Equiv.arrowCongr`,
  for additive maps from an additive monoid to a commutative additive monoid."]
-- Porting note: @[simps apply] removed because it was making a lemma which
-- wasn't in simp normal form.
def monoidHomCongr {M N P Q} [MulOneClass M] [MulOneClass N] [CommMonoid P] [CommMonoid Q]
    (f : M ≃* N) (g : P ≃* Q) : (M →* P) ≃* (N →* Q) 
Arguments: {M : Type u_12} {N : Type u_13} {P : Type u_14} {Q : Type u_15} [AddZeroClass M] [AddZeroClass N] [AddCommMonoid P] [AddCommMonoid Q] (f : M ≃+ N) (g : P ≃+ Q) (h : M →+ P)
Goal: (f.addMonoidHomCongr g) h = g.toAddMonoidHom.comp (h.comp f.symm.toAddMonoidHom)
-- MulEquiv.piCongrRight_apply
@[to_additive (attr := simps apply)
  "A family of additive equivalences `Π j, (Ms j ≃+ Ns j)`
  generates an additive equivalence between `Π j, Ms j` and `Π j, Ns j`.

  This is the `AddEquiv` version of `Equiv.piCongrRight`, and the dependent version of
  `AddEquiv.arrowCongr`."]
def piCongrRight {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
    (es : ∀ j, Ms j ≃* Ns j) : (∀ j, Ms j) ≃* ∀ j, Ns j 
Arguments: {η : Type u_12} {Ms : η → Type u_13} {Ns : η → Type u_14} [(j : η) → Mul (Ms j)] [(j : η) → Mul (Ns j)] (es : (j : η) → Ms j ≃* Ns j) (x : (j : η) → Ms j) (j : η)
Goal: (MulEquiv.piCongrRight es) x j = (es j) (x j)
-- AddEquiv.piCongrRight_apply
@[to_additive (attr := simps apply)
  "A family of additive equivalences `Π j, (Ms j ≃+ Ns j)`
  generates an additive equivalence between `Π j, Ms j` and `Π j, Ns j`.

  This is the `AddEquiv` version of `Equiv.piCongrRight`, and the dependent version of
  `AddEquiv.arrowCongr`."]
def piCongrRight {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
    (es : ∀ j, Ms j ≃* Ns j) : (∀ j, Ms j) ≃* ∀ j, Ns j 
Arguments: {η : Type u_12} {Ms : η → Type u_13} {Ns : η → Type u_14} [(j : η) → Add (Ms j)] [(j : η) → Add (Ns j)] (es : (j : η) → Ms j ≃+ Ns j) (x : (j : η) → Ms j) (j : η)
Goal: (AddEquiv.piCongrRight es) x j = (es j) (x j)
-- MulEquiv.piCongrRight_refl
@[to_additive (attr := simp)]
theorem piCongrRight_refl {η : Type*} {Ms : η → Type*} [∀ j, Mul (Ms j)] :
    (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ 
Arguments: {η : Type u_12} {Ms : η → Type u_13} [(j : η) → Mul (Ms j)]
Goal: (MulEquiv.piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl ((j : η) → Ms j)
-- AddEquiv.piCongrRight_refl
@[to_additive (attr := simp)]
theorem piCongrRight_refl {η : Type*} {Ms : η → Type*} [∀ j, Mul (Ms j)] :
    (piCongrRight fun j => MulEquiv.refl (Ms j)) = MulEquiv.refl _ 
Arguments: {η : Type u_12} {Ms : η → Type u_13} [(j : η) → Add (Ms j)]
Goal: (AddEquiv.piCongrRight fun j => AddEquiv.refl (Ms j)) = AddEquiv.refl ((j : η) → Ms j)
-- MulEquiv.piCongrRight_symm
@[to_additive (attr := simp)]
theorem piCongrRight_symm {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
    (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm 
Arguments: {η : Type u_12} {Ms : η → Type u_13} {Ns : η → Type u_14} [(j : η) → Mul (Ms j)] [(j : η) → Mul (Ns j)] (es : (j : η) → Ms j ≃* Ns j)
Goal: (MulEquiv.piCongrRight es).symm = MulEquiv.piCongrRight fun i => (es i).symm
-- AddEquiv.piCongrRight_symm
@[to_additive (attr := simp)]
theorem piCongrRight_symm {η : Type*} {Ms Ns : η → Type*} [∀ j, Mul (Ms j)] [∀ j, Mul (Ns j)]
    (es : ∀ j, Ms j ≃* Ns j) : (piCongrRight es).symm = piCongrRight fun i => (es i).symm 
Arguments: {η : Type u_12} {Ms : η → Type u_13} {Ns : η → Type u_14} [(j : η) → Add (Ms j)] [(j : η) → Add (Ns j)] (es : (j : η) → Ms j ≃+ Ns j)
Goal: (AddEquiv.piCongrRight es).symm = AddEquiv.piCongrRight fun i => (es i).symm
-- AddEquiv.piCongrRight_trans
@[to_additive (attr := simp)]
theorem piCongrRight_trans {η : Type*} {Ms Ns Ps : η → Type*} [∀ j, Mul (Ms j)]
    [∀ j, Mul (Ns j)] [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
    (piCongrRight es).trans (piCongrRight fs) = piCongrRight fun i => (es i).trans (fs i) 
Arguments: {η : Type u_12} {Ms : η → Type u_13} {Ns : η → Type u_14} {Ps : η → Type u_15} [(j : η) → Add (Ms j)] [(j : η) → Add (Ns j)] [(j : η) → Add (Ps j)] (es : (j : η) → Ms j ≃+ Ns j) (fs : (j : η) → Ns j ≃+ Ps j)
Goal: (AddEquiv.piCongrRight es).trans (AddEquiv.piCongrRight fs) = AddEquiv.piCongrRight fun i => (es i).trans (fs i)
-- MulEquiv.piCongrRight_trans
@[to_additive (attr := simp)]
theorem piCongrRight_trans {η : Type*} {Ms Ns Ps : η → Type*} [∀ j, Mul (Ms j)]
    [∀ j, Mul (Ns j)] [∀ j, Mul (Ps j)] (es : ∀ j, Ms j ≃* Ns j) (fs : ∀ j, Ns j ≃* Ps j) :
    (piCongrRight es).trans (piCongrRight fs) = piCongrRight fun i => (es i).trans (fs i) 
Arguments: {η : Type u_12} {Ms : η → Type u_13} {Ns : η → Type u_14} {Ps : η → Type u_15} [(j : η) → Mul (Ms j)] [(j : η) → Mul (Ns j)] [(j : η) → Mul (Ps j)] (es : (j : η) → Ms j ≃* Ns j) (fs : (j : η) → Ns j ≃* Ps j)
Goal: (MulEquiv.piCongrRight es).trans (MulEquiv.piCongrRight fs) = MulEquiv.piCongrRight fun i => (es i).trans (fs i)
-- MulEquiv.piUnique_symm_apply
@[to_additive (attr := simps!)
  "A family indexed by a type with a unique element
  is `AddEquiv` to the element at the single index."]
def piUnique {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Unique ι] :
    (∀ j, M j) ≃* M default 
Arguments: {ι : Type u_12} (M : ι → Type u_13) [(j : ι) → Mul (M j)] [Unique ι] (x : M default) (i : ι)
Goal: (MulEquiv.piUnique M).symm x i = uniqueElim x i
-- AddEquiv.piUnique_symm_apply
@[to_additive (attr := simps!)
  "A family indexed by a type with a unique element
  is `AddEquiv` to the element at the single index."]
def piUnique {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Unique ι] :
    (∀ j, M j) ≃* M default 
Arguments: {ι : Type u_12} (M : ι → Type u_13) [(j : ι) → Add (M j)] [Unique ι] (x : M default) (i : ι)
Goal: (AddEquiv.piUnique M).symm x i = uniqueElim x i
-- AddEquiv.piUnique_apply
@[to_additive (attr := simps!)
  "A family indexed by a type with a unique element
  is `AddEquiv` to the element at the single index."]
def piUnique {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Unique ι] :
    (∀ j, M j) ≃* M default 
Arguments: {ι : Type u_12} (M : ι → Type u_13) [(j : ι) → Add (M j)] [Unique ι] (f : (i : ι) → M i)
Goal: (AddEquiv.piUnique M) f = f default
-- MulEquiv.piUnique_apply
@[to_additive (attr := simps!)
  "A family indexed by a type with a unique element
  is `AddEquiv` to the element at the single index."]
def piUnique {ι : Type*} (M : ι → Type*) [∀ j, Mul (M j)] [Unique ι] :
    (∀ j, M j) ≃* M default 
Arguments: {ι : Type u_12} (M : ι → Type u_13) [(j : ι) → Mul (M j)] [Unique ι] (f : (i : ι) → M i)
Goal: (MulEquiv.piUnique M) f = f default
-- AddEquiv.map_neg
@[to_additive "An additive equivalence of additive groups preserves negation."]
protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) :
    h x⁻¹ = (h x)⁻¹ 
Arguments: {G : Type u_10} {H : Type u_11} [AddGroup G] [SubtractionMonoid H] (h : G ≃+ H) (x : G)
Goal: h (-x) = -h x
-- MulEquiv.map_inv
@[to_additive "An additive equivalence of additive groups preserves negation."]
protected theorem map_inv [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G) :
    h x⁻¹ = (h x)⁻¹ 
Arguments: {G : Type u_10} {H : Type u_11} [Group G] [DivisionMonoid H] (h : G ≃* H) (x : G)
Goal: h x⁻¹ = (h x)⁻¹
-- AddEquiv.map_sub
@[to_additive "An additive equivalence of additive groups preserves subtractions."]
protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G) :
    h (x / y) = h x / h y 
Arguments: {G : Type u_10} {H : Type u_11} [AddGroup G] [SubtractionMonoid H] (h : G ≃+ H) (x y : G)
Goal: h (x - y) = h x - h y
-- MulEquiv.map_div
@[to_additive "An additive equivalence of additive groups preserves subtractions."]
protected theorem map_div [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G) :
    h (x / y) = h x / h y 
Arguments: {G : Type u_10} {H : Type u_11} [Group G] [DivisionMonoid H] (h : G ≃* H) (x y : G)
Goal: h (x / y) = h x / h y
-- AddHom.toAddEquiv_apply
@[to_additive (attr := simp)]
theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
    ((MulHom.toMulEquiv f g h₁ h₂) : M → N) = f 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : AddHom M N) (g : AddHom N M) (h₁ : g.comp f = AddHom.id M) (h₂ : f.comp g = AddHom.id N)
Goal: ⇑(f.toAddEquiv g h₁ h₂) = ⇑f
-- MulHom.toMulEquiv_apply
@[to_additive (attr := simp)]
theorem MulHom.toMulEquiv_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
    ((MulHom.toMulEquiv f g h₁ h₂) : M → N) = f 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁ : g.comp f = MulHom.id M) (h₂ : f.comp g = MulHom.id N)
Goal: ⇑(f.toMulEquiv g h₁ h₂) = ⇑f
-- AddHom.toAddEquiv_symm_apply
@[to_additive (attr := simp)]
theorem MulHom.toMulEquiv_symm_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
    (MulEquiv.symm (MulHom.toMulEquiv f g h₁ h₂) : N → M) = ↑g 
Arguments: {M : Type u_6} {N : Type u_7} [Add M] [Add N] (f : AddHom M N) (g : AddHom N M) (h₁ : g.comp f = AddHom.id M) (h₂ : f.comp g = AddHom.id N)
Goal: ⇑(f.toAddEquiv g h₁ h₂).symm = ⇑g
-- MulHom.toMulEquiv_symm_apply
@[to_additive (attr := simp)]
theorem MulHom.toMulEquiv_symm_apply [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M)
    (h₁ : g.comp f = MulHom.id _) (h₂ : f.comp g = MulHom.id _) :
    (MulEquiv.symm (MulHom.toMulEquiv f g h₁ h₂) : N → M) = ↑g 
Arguments: {M : Type u_6} {N : Type u_7} [Mul M] [Mul N] (f : M →ₙ* N) (g : N →ₙ* M) (h₁ : g.comp f = MulHom.id M) (h₂ : f.comp g = MulHom.id N)
Goal: ⇑(f.toMulEquiv g h₁ h₂).symm = ⇑g
-- AddMonoidHom.toAddEquiv_symm_apply
@[to_additive (attr := simps (config := .asFn))
  "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`
  and `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`.  This
  constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
  monoid homomorphisms."]
def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M)
    (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N 
Arguments: {M : Type u_6} {N : Type u_7} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (g : N →+ M) (h₁ : g.comp f = AddMonoidHom.id M) (h₂ : f.comp g = AddMonoidHom.id N)
Goal: ⇑(f.toAddEquiv g h₁ h₂).symm = ⇑g
-- MonoidHom.toMulEquiv_apply
@[to_additive (attr := simps (config := .asFn))
  "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`
  and `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`.  This
  constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
  monoid homomorphisms."]
def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M)
    (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N 
Arguments: {M : Type u_6} {N : Type u_7} [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M) (h₁ : g.comp f = MonoidHom.id M) (h₂ : f.comp g = MonoidHom.id N)
Goal: ⇑(f.toMulEquiv g h₁ h₂) = ⇑f
-- AddMonoidHom.toAddEquiv_apply
@[to_additive (attr := simps (config := .asFn))
  "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`
  and `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`.  This
  constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
  monoid homomorphisms."]
def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M)
    (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N 
Arguments: {M : Type u_6} {N : Type u_7} [AddZeroClass M] [AddZeroClass N] (f : M →+ N) (g : N →+ M) (h₁ : g.comp f = AddMonoidHom.id M) (h₂ : f.comp g = AddMonoidHom.id N)
Goal: ⇑(f.toAddEquiv g h₁ h₂) = ⇑f
-- MonoidHom.toMulEquiv_symm_apply
@[to_additive (attr := simps (config := .asFn))
  "Given a pair of additive monoid homomorphisms `f`, `g` such that `g.comp f = id`
  and `f.comp g = id`, returns an additive equivalence with `toFun = f` and `invFun = g`.  This
  constructor is useful if the underlying type(s) have specialized `ext` lemmas for additive
  monoid homomorphisms."]
def MonoidHom.toMulEquiv [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M)
    (h₁ : g.comp f = MonoidHom.id _) (h₂ : f.comp g = MonoidHom.id _) : M ≃* N 
Arguments: {M : Type u_6} {N : Type u_7} [MulOneClass M] [MulOneClass N] (f : M →* N) (g : N →* M) (h₁ : g.comp f = MonoidHom.id M) (h₂ : f.comp g = MonoidHom.id N)
Goal: ⇑(f.toMulEquiv g h₁ h₂).symm = ⇑g
-- Equiv.inv_apply
@[to_additive (attr := simps! (config := .asFn) apply)
    "Negation on an `AddGroup` is a permutation of the underlying type."]
protected def inv : Perm G 
Arguments: (G : Type u_10) [InvolutiveInv G]
Goal: ⇑(Equiv.inv G) = Inv.inv
-- Equiv.neg_apply
@[to_additive (attr := simps! (config := .asFn) apply)
    "Negation on an `AddGroup` is a permutation of the underlying type."]
protected def inv : Perm G 
Arguments: (G : Type u_10) [InvolutiveNeg G]
Goal: ⇑(Equiv.neg G) = Neg.neg
-- Equiv.inv_symm
@[to_additive (attr := simp)]
theorem inv_symm : (Equiv.inv G).symm = Equiv.inv G 
Arguments: {G : Type u_10} [InvolutiveInv G]
Goal: Equiv.symm (Equiv.inv G) = Equiv.inv G
-- Equiv.neg_symm
@[to_additive (attr := simp)]
theorem inv_symm : (Equiv.inv G).symm = Equiv.inv G 
Arguments: {G : Type u_10} [InvolutiveNeg G]
Goal: Equiv.symm (Equiv.neg G) = Equiv.neg G
-- Fin.insertNth_one_right
@[to_additive (attr := simp)]
lemma insertNth_one_right [∀ j, One (α j)] (i : Fin (n + 1)) (x : α i) :
    i.insertNth x 1 = Pi.mulSingle i x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → One (α j)] (i : Fin (n + 1)) (x : α i)
Goal: i.insertNth x 1 = Pi.mulSingle i x
-- Fin.insertNth_zero_right
@[to_additive (attr := simp)]
lemma insertNth_one_right [∀ j, One (α j)] (i : Fin (n + 1)) (x : α i) :
    i.insertNth x 1 = Pi.mulSingle i x 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → Zero (α j)] (i : Fin (n + 1)) (x : α i)
Goal: i.insertNth x 0 = Pi.single i x
-- Fin.insertNth_mul
@[to_additive (attr := simp)]
lemma insertNth_mul [∀ j, Mul (α j)] (i : Fin (n + 1)) (x y : α i) (p q : ∀ j, α (i.succAbove j)) :
    i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → Mul (α j)] (i : Fin (n + 1)) (x y : α i) (p q : (j : Fin n) → α (i.succAbove j))
Goal: i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q
-- Fin.insertNth_add
@[to_additive (attr := simp)]
lemma insertNth_mul [∀ j, Mul (α j)] (i : Fin (n + 1)) (x y : α i) (p q : ∀ j, α (i.succAbove j)) :
    i.insertNth (x * y) (p * q) = i.insertNth x p * i.insertNth y q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → Add (α j)] (i : Fin (n + 1)) (x y : α i) (p q : (j : Fin n) → α (i.succAbove j))
Goal: i.insertNth (x + y) (p + q) = i.insertNth x p + i.insertNth y q
-- Fin.insertNth_div
@[to_additive (attr := simp)]
lemma insertNth_div [∀ j, Div (α j)] (i : Fin (n + 1)) (x y : α i)(p q : ∀ j, α (i.succAbove j)) :
    i.insertNth (x / y) (p / q) = i.insertNth x p / i.insertNth y q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → Div (α j)] (i : Fin (n + 1)) (x y : α i) (p q : (j : Fin n) → α (i.succAbove j))
Goal: i.insertNth (x / y) (p / q) = i.insertNth x p / i.insertNth y q
-- Fin.insertNth_sub
@[to_additive (attr := simp)]
lemma insertNth_div [∀ j, Div (α j)] (i : Fin (n + 1)) (x y : α i)(p q : ∀ j, α (i.succAbove j)) :
    i.insertNth (x / y) (p / q) = i.insertNth x p / i.insertNth y q 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → Sub (α j)] (i : Fin (n + 1)) (x y : α i) (p q : (j : Fin n) → α (i.succAbove j))
Goal: i.insertNth (x - y) (p - q) = i.insertNth x p - i.insertNth y q
-- Fin.insertNth_sub_same
@[to_additive (attr := simp)]
lemma insertNth_div_same [∀ j, Group (α j)] (i : Fin (n + 1)) (x y : α i)
    (p : ∀ j, α (i.succAbove j)) : i.insertNth x p / i.insertNth y p = Pi.mulSingle i (x / y) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → AddGroup (α j)] (i : Fin (n + 1)) (x y : α i) (p : (j : Fin n) → α (i.succAbove j))
Goal: i.insertNth x p - i.insertNth y p = Pi.single i (x - y)
-- Fin.insertNth_div_same
@[to_additive (attr := simp)]
lemma insertNth_div_same [∀ j, Group (α j)] (i : Fin (n + 1)) (x y : α i)
    (p : ∀ j, α (i.succAbove j)) : i.insertNth x p / i.insertNth y p = Pi.mulSingle i (x / y) 
Arguments: {n : ℕ} {α : Fin (n + 1) → Type u_1} [(j : Fin (n + 1)) → Group (α j)] (i : Fin (n + 1)) (x y : α i) (p : (j : Fin n) → α (i.succAbove j))
Goal: i.insertNth x p / i.insertNth y p = Pi.mulSingle i (x / y)
-- Matrix.smul_empty
@[simp] lemma smul_empty (x : M) (v : Fin 0 → α) : x • v = ![] 
Arguments: {α : Type u_1} {M : Type u_2} [SMul M α] (x : M) (v : Fin 0 → α)
Goal: x • v = ![]
-- Matrix.smul_cons
@[simp] lemma smul_cons (x : M) (y : α) (v : Fin n → α) :
    x • vecCons y v = vecCons (x • y) (x • v) 
Arguments: {α : Type u_1} {M : Type u_2} {n : ℕ} [SMul M α] (x : M) (y : α) (v : Fin n → α)
Goal: x • Matrix.vecCons y v = Matrix.vecCons (x • y) (x • v)
-- Matrix.empty_add_empty
@[simp] lemma empty_add_empty (v w : Fin 0 → α) : v + w = ![] 
Arguments: {α : Type u_1} [Add α] (v w : Fin 0 → α)
Goal: v + w = ![]
-- Matrix.cons_add
@[simp] lemma cons_add (x : α) (v : Fin n → α) (w : Fin n.succ → α) :
    vecCons x v + w = vecCons (x + vecHead w) (v + vecTail w) 
Arguments: {α : Type u_1} {n : ℕ} [Add α] (x : α) (v : Fin n → α) (w : Fin n.succ → α)
Goal: Matrix.vecCons x v + w = Matrix.vecCons (x + Matrix.vecHead w) (v + Matrix.vecTail w)
-- Matrix.add_cons
@[simp] lemma add_cons (v : Fin n.succ → α) (y : α) (w : Fin n → α) :
    v + vecCons y w = vecCons (vecHead v + y) (vecTail v + w) 
Arguments: {α : Type u_1} {n : ℕ} [Add α] (v : Fin n.succ → α) (y : α) (w : Fin n → α)
Goal: v + Matrix.vecCons y w = Matrix.vecCons (Matrix.vecHead v + y) (Matrix.vecTail v + w)
-- Matrix.cons_add_cons
lemma cons_add_cons (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) :
    vecCons x v + vecCons y w = vecCons (x + y) (v + w) 
Arguments: {α : Type u_1} {n : ℕ} [Add α] (x : α) (v : Fin n → α) (y : α) (w : Fin n → α)
Goal: Matrix.vecCons x v + Matrix.vecCons y w = Matrix.vecCons (x + y) (v + w)
-- Matrix.head_add
@[simp] lemma head_add (a b : Fin n.succ → α) : vecHead (a + b) = vecHead a + vecHead b 
Arguments: {α : Type u_1} {n : ℕ} [Add α] (a b : Fin n.succ → α)
Goal: Matrix.vecHead (a + b) = Matrix.vecHead a + Matrix.vecHead b
-- Matrix.tail_add
@[simp] lemma tail_add (a b : Fin n.succ → α) : vecTail (a + b) = vecTail a + vecTail b 
Arguments: {α : Type u_1} {n : ℕ} [Add α] (a b : Fin n.succ → α)
Goal: Matrix.vecTail (a + b) = Matrix.vecTail a + Matrix.vecTail b
-- Matrix.empty_sub_empty
@[simp] lemma empty_sub_empty (v w : Fin 0 → α) : v - w = ![] 
Arguments: {α : Type u_1} [Sub α] (v w : Fin 0 → α)
Goal: v - w = ![]
-- Matrix.cons_sub
@[simp] lemma cons_sub (x : α) (v : Fin n → α) (w : Fin n.succ → α) :
    vecCons x v - w = vecCons (x - vecHead w) (v - vecTail w) 
Arguments: {α : Type u_1} {n : ℕ} [Sub α] (x : α) (v : Fin n → α) (w : Fin n.succ → α)
Goal: Matrix.vecCons x v - w = Matrix.vecCons (x - Matrix.vecHead w) (v - Matrix.vecTail w)
-- Matrix.sub_cons
@[simp] lemma sub_cons (v : Fin n.succ → α) (y : α) (w : Fin n → α) :
    v - vecCons y w = vecCons (vecHead v - y) (vecTail v - w) 
Arguments: {α : Type u_1} {n : ℕ} [Sub α] (v : Fin n.succ → α) (y : α) (w : Fin n → α)
Goal: v - Matrix.vecCons y w = Matrix.vecCons (Matrix.vecHead v - y) (Matrix.vecTail v - w)
-- Matrix.cons_sub_cons
lemma cons_sub_cons (x : α) (v : Fin n → α) (y : α) (w : Fin n → α) :
    vecCons x v - vecCons y w = vecCons (x - y) (v - w) 
Arguments: {α : Type u_1} {n : ℕ} [Sub α] (x : α) (v : Fin n → α) (y : α) (w : Fin n → α)
Goal: Matrix.vecCons x v - Matrix.vecCons y w = Matrix.vecCons (x - y) (v - w)
-- Matrix.head_sub
@[simp] lemma head_sub (a b : Fin n.succ → α) : vecHead (a - b) = vecHead a - vecHead b 
Arguments: {α : Type u_1} {n : ℕ} [Sub α] (a b : Fin n.succ → α)
Goal: Matrix.vecHead (a - b) = Matrix.vecHead a - Matrix.vecHead b
-- Matrix.tail_sub
@[simp] lemma tail_sub (a b : Fin n.succ → α) : vecTail (a - b) = vecTail a - vecTail b 
Arguments: {α : Type u_1} {n : ℕ} [Sub α] (a b : Fin n.succ → α)
Goal: Matrix.vecTail (a - b) = Matrix.vecTail a - Matrix.vecTail b
-- Matrix.zero_empty
@[simp] lemma zero_empty : (0 : Fin 0 → α) = ![] 
Arguments: {α : Type u_1} [Zero α]
Goal: 0 = ![]
-- Matrix.cons_zero_zero
@[simp] lemma cons_zero_zero : vecCons (0 : α) (0 : Fin n → α) = 0 
Arguments: {α : Type u_1} {n : ℕ} [Zero α]
Goal: Matrix.vecCons 0 0 = 0
-- Matrix.head_zero
@[simp] lemma head_zero : vecHead (0 : Fin n.succ → α) = 0 
Arguments: {α : Type u_1} {n : ℕ} [Zero α]
Goal: Matrix.vecHead 0 = 0
-- Matrix.tail_zero
@[simp] lemma tail_zero : vecTail (0 : Fin n.succ → α) = 0 
Arguments: {α : Type u_1} {n : ℕ} [Zero α]
Goal: Matrix.vecTail 0 = 0
-- Matrix.cons_eq_zero_iff
@[simp] lemma cons_eq_zero_iff {v : Fin n → α} {x : α} : vecCons x v = 0 ↔ x = 0 ∧ v = 0 
Arguments: {α : Type u_1} {n : ℕ} [Zero α] {v : Fin n → α} {x : α}
Goal: Matrix.vecCons x v = 0 ↔ x = 0 ∧ v = 0
-- Matrix.cons_nonzero_iff
lemma cons_nonzero_iff {v : Fin n → α} {x : α} : vecCons x v ≠ 0 ↔ x ≠ 0 ∨ v ≠ 0 
Arguments: {α : Type u_1} {n : ℕ} [Zero α] {v : Fin n → α} {x : α}
Goal: Matrix.vecCons x v ≠ 0 ↔ x ≠ 0 ∨ v ≠ 0
-- Matrix.neg_empty
@[simp] lemma neg_empty (v : Fin 0 → α) : -v = ![] 
Arguments: {α : Type u_1} [Neg α] (v : Fin 0 → α)
Goal: -v = ![]