ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- IsCentralScalar.unop_smul_eq_smul
@[to_additive]
lemma IsCentralScalar.unop_smul_eq_smul {M α : Type*} [SMul M α] [SMul Mᵐᵒᵖ α]
    [IsCentralScalar M α] (m : Mᵐᵒᵖ) (a : α) : MulOpposite.unop m • a = m • a 
Arguments: {M : Type u_11} {α : Type u_12} [SMul M α] [SMul Mᵐᵒᵖ α] [IsCentralScalar M α] (m : Mᵐᵒᵖ) (a : α)
Goal: MulOpposite.unop m • a = m • a
-- SMul.comp.isScalarTower
@[to_additive
"Given a tower of additive actions `M → α → β`, if we use `SMul.comp` to pull back both of
`M`'s actions by a map `g : N → M`, then we obtain a new tower of scalar actions `N → α → β`.

This cannot be an instance because it can cause infinite loops whenever the `SMul` arguments
are still metavariables."]
lemma comp.isScalarTower [SMul M β] [SMul α β] [IsScalarTower M α β] (g : N → M) : by
    haveI := comp α g; haveI := comp β g; exact IsScalarTower N α β 
Arguments: {M : Type u_1} {N : Type u_2} {α : Type u_7} {β : Type u_8} [SMul M α] [SMul M β] [SMul α β] [IsScalarTower M α β] (g : N → M)
Goal: IsScalarTower N α β
-- VAdd.comp.isScalarTower
@[to_additive
"Given a tower of additive actions `M → α → β`, if we use `SMul.comp` to pull back both of
`M`'s actions by a map `g : N → M`, then we obtain a new tower of scalar actions `N → α → β`.

This cannot be an instance because it can cause infinite loops whenever the `SMul` arguments
are still metavariables."]
lemma comp.isScalarTower [SMul M β] [SMul α β] [IsScalarTower M α β] (g : N → M) : by
    haveI := comp α g; haveI := comp β g; exact IsScalarTower N α β 
Arguments: {M : Type u_1} {N : Type u_2} {α : Type u_7} {β : Type u_8} [VAdd M α] [VAdd M β] [VAdd α β] [VAddAssocClass M α β] (g : N → M)
Goal: VAddAssocClass N α β
-- VAdd.comp.vaddCommClass
@[to_additive
"This cannot be an instance because it can cause infinite loops whenever the `VAdd` arguments
are still metavariables."]
lemma comp.smulCommClass [SMul β α] [SMulCommClass M β α] (g : N → M) :
    haveI := comp α g
    SMulCommClass N β α 
Arguments: {M : Type u_1} {N : Type u_2} {α : Type u_7} {β : Type u_8} [VAdd M α] [VAdd β α] [VAddCommClass M β α] (g : N → M)
Goal: VAddCommClass N β α
-- SMul.comp.smulCommClass
@[to_additive
"This cannot be an instance because it can cause infinite loops whenever the `VAdd` arguments
are still metavariables."]
lemma comp.smulCommClass [SMul β α] [SMulCommClass M β α] (g : N → M) :
    haveI := comp α g
    SMulCommClass N β α 
Arguments: {M : Type u_1} {N : Type u_2} {α : Type u_7} {β : Type u_8} [SMul M α] [SMul β α] [SMulCommClass M β α] (g : N → M)
Goal: SMulCommClass N β α
-- VAdd.comp.vaddCommClass'
@[to_additive
"This cannot be an instance because it can cause infinite loops whenever the `VAdd` arguments
are still metavariables."]
lemma comp.smulCommClass' [SMul β α] [SMulCommClass β M α] (g : N → M) :
    haveI := comp α g
    SMulCommClass β N α 
Arguments: {M : Type u_1} {N : Type u_2} {α : Type u_7} {β : Type u_8} [VAdd M α] [VAdd β α] [VAddCommClass β M α] (g : N → M)
Goal: VAddCommClass β N α
-- SMul.comp.smulCommClass'
@[to_additive
"This cannot be an instance because it can cause infinite loops whenever the `VAdd` arguments
are still metavariables."]
lemma comp.smulCommClass' [SMul β α] [SMulCommClass β M α] (g : N → M) :
    haveI := comp α g
    SMulCommClass β N α 
Arguments: {M : Type u_1} {N : Type u_2} {α : Type u_7} {β : Type u_8} [SMul M α] [SMul β α] [SMulCommClass β M α] (g : N → M)
Goal: SMulCommClass β N α
-- add_vadd_comm
@[to_additive] -- Porting note: nolint to_additive_doc
lemma mul_smul_comm [Mul β] [SMul α β] [SMulCommClass α β β] (s : α) (x y : β) :
    x * s • y = s • (x * y) 
Arguments: {α : Type u_7} {β : Type u_8} [Add β] [VAdd α β] [VAddCommClass α β β] (s : α) (x y : β)
Goal: x + (s +ᵥ y) = s +ᵥ (x + y)
-- mul_smul_comm
@[to_additive] -- Porting note: nolint to_additive_doc
lemma mul_smul_comm [Mul β] [SMul α β] [SMulCommClass α β β] (s : α) (x y : β) :
    x * s • y = s • (x * y) 
Arguments: {α : Type u_7} {β : Type u_8} [Mul β] [SMul α β] [SMulCommClass α β β] (s : α) (x y : β)
Goal: x * s • y = s • (x * y)
-- vadd_add_assoc
@[to_additive] -- Porting note: nolint to_additive_doc
lemma smul_mul_assoc [Mul β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β) :
    r • x * y = r • (x * y) 
Arguments: {α : Type u_7} {β : Type u_8} [Add β] [VAdd α β] [VAddAssocClass α β β] (r : α) (x y : β)
Goal: r +ᵥ x + y = r +ᵥ (x + y)
-- smul_mul_assoc
@[to_additive] -- Porting note: nolint to_additive_doc
lemma smul_mul_assoc [Mul β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β) :
    r • x * y = r • (x * y) 
Arguments: {α : Type u_7} {β : Type u_8} [Mul β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β)
Goal: r • x * y = r • (x * y)
-- vadd_sub_assoc
@[to_additive]
lemma smul_div_assoc [DivInvMonoid β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β) :
    r • x / y = r • (x / y) 
Arguments: {α : Type u_7} {β : Type u_8} [SubNegMonoid β] [VAdd α β] [VAddAssocClass α β β] (r : α) (x y : β)
Goal: r +ᵥ x - y = r +ᵥ (x - y)
-- smul_div_assoc
@[to_additive]
lemma smul_div_assoc [DivInvMonoid β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β) :
    r • x / y = r • (x / y) 
Arguments: {α : Type u_7} {β : Type u_8} [DivInvMonoid β] [SMul α β] [IsScalarTower α β β] (r : α) (x y : β)
Goal: r • x / y = r • (x / y)
-- vadd_vadd_vadd_comm
@[to_additive]
lemma smul_smul_smul_comm [SMul α β] [SMul α γ] [SMul β δ] [SMul α δ] [SMul γ δ]
    [IsScalarTower α β δ] [IsScalarTower α γ δ] [SMulCommClass β γ δ] (a : α) (b : β) (c : γ)
    (d : δ) : (a • b) • c • d = (a • c) • b • d 
Arguments: {α : Type u_7} {β : Type u_8} {γ : Type u_9} {δ : Type u_10} [VAdd α β] [VAdd α γ] [VAdd β δ] [VAdd α δ] [VAdd γ δ] [VAddAssocClass α β δ] [VAddAssocClass α γ δ] [VAddCommClass β γ δ] (a : α) (b : β) (c : γ) (d : δ)
Goal: a +ᵥ b +ᵥ (c +ᵥ d) = a +ᵥ c +ᵥ (b +ᵥ d)
-- smul_smul_smul_comm
@[to_additive]
lemma smul_smul_smul_comm [SMul α β] [SMul α γ] [SMul β δ] [SMul α δ] [SMul γ δ]
    [IsScalarTower α β δ] [IsScalarTower α γ δ] [SMulCommClass β γ δ] (a : α) (b : β) (c : γ)
    (d : δ) : (a • b) • c • d = (a • c) • b • d 
Arguments: {α : Type u_7} {β : Type u_8} {γ : Type u_9} {δ : Type u_10} [SMul α β] [SMul α γ] [SMul β δ] [SMul α δ] [SMul γ δ] [IsScalarTower α β δ] [IsScalarTower α γ δ] [SMulCommClass β γ δ] (a : α) (b : β) (c : γ) (d : δ)
Goal: (a • b) • c • d = (a • c) • b • d
-- AddCommute.vadd_right
@[to_additive]
lemma Commute.smul_right [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α}
    (h : Commute a b) (r : M) : Commute a (r • b) 
Arguments: {M : Type u_1} {α : Type u_7} [VAdd M α] [Add α] [VAddCommClass M α α] [VAddAssocClass M α α] {a b : α} (h : AddCommute a b) (r : M)
Goal: AddCommute a (r +ᵥ b)
-- Commute.smul_right
@[to_additive]
lemma Commute.smul_right [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α}
    (h : Commute a b) (r : M) : Commute a (r • b) 
Arguments: {M : Type u_1} {α : Type u_7} [SMul M α] [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α} (h : Commute a b) (r : M)
Goal: Commute a (r • b)
-- AddCommute.vadd_left
@[to_additive]
lemma Commute.smul_left [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α}
    (h : Commute a b) (r : M) : Commute (r • a) b 
Arguments: {M : Type u_1} {α : Type u_7} [VAdd M α] [Add α] [VAddCommClass M α α] [VAddAssocClass M α α] {a b : α} (h : AddCommute a b) (r : M)
Goal: AddCommute (r +ᵥ a) b
-- Commute.smul_left
@[to_additive]
lemma Commute.smul_left [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α}
    (h : Commute a b) (r : M) : Commute (r • a) b 
Arguments: {M : Type u_1} {α : Type u_7} [SMul M α] [Mul α] [SMulCommClass M α α] [IsScalarTower M α α] {a b : α} (h : Commute a b) (r : M)
Goal: Commute (r • a) b
-- vadd_vadd
@[to_additive]
lemma smul_smul (a₁ a₂ : M) (b : α) : a₁ • a₂ • b = (a₁ * a₂) • b 
Arguments: {M : Type u_1} {α : Type u_7} [AddMonoid M] [AddAction M α] (a₁ a₂ : M) (b : α)
Goal: a₁ +ᵥ (a₂ +ᵥ b) = a₁ + a₂ +ᵥ b
-- smul_smul
@[to_additive]
lemma smul_smul (a₁ a₂ : M) (b : α) : a₁ • a₂ • b = (a₁ * a₂) • b 
Arguments: {M : Type u_1} {α : Type u_7} [Monoid M] [MulAction M α] (a₁ a₂ : M) (b : α)
Goal: a₁ • a₂ • b = (a₁ * a₂) • b
-- one_smul
@[to_additive (attr := simp)]
lemma one_smul (b : α) : (1 : M) • b = b 
Arguments: (M : Type u_1) {α : Type u_7} [Monoid M] [MulAction M α] (b : α)
Goal: 1 • b = b
-- zero_vadd
@[to_additive (attr := simp)]
lemma one_smul (b : α) : (1 : M) • b = b 
Arguments: (M : Type u_1) {α : Type u_7} [AddMonoid M] [AddAction M α] (b : α)
Goal: 0 +ᵥ b = b
-- one_smul_eq_id
@[to_additive "`VAdd` version of `zero_add_eq_id`"]
lemma one_smul_eq_id : (((1 : M) • ·) : α → α) = id 
Arguments: (M : Type u_1) {α : Type u_7} [Monoid M] [MulAction M α]
Goal: (fun x => 1 • x) = id
-- zero_vadd_eq_id
@[to_additive "`VAdd` version of `zero_add_eq_id`"]
lemma one_smul_eq_id : (((1 : M) • ·) : α → α) = id 
Arguments: (M : Type u_1) {α : Type u_7} [AddMonoid M] [AddAction M α]
Goal: (fun x => 0 +ᵥ x) = id
-- comp_vadd_left
@[to_additive "`VAdd` version of `comp_add_left`"]
lemma comp_smul_left (a₁ a₂ : M) : (a₁ • ·) ∘ (a₂ • ·) = (((a₁ * a₂) • ·) : α → α) 
Arguments: (M : Type u_1) {α : Type u_7} [AddMonoid M] [AddAction M α] (a₁ a₂ : M)
Goal: ((fun x => a₁ +ᵥ x) ∘ fun x => a₂ +ᵥ x) = fun x => a₁ + a₂ +ᵥ x
-- comp_smul_left
@[to_additive "`VAdd` version of `comp_add_left`"]
lemma comp_smul_left (a₁ a₂ : M) : (a₁ • ·) ∘ (a₂ • ·) = (((a₁ * a₂) • ·) : α → α) 
Arguments: (M : Type u_1) {α : Type u_7} [Monoid M] [MulAction M α] (a₁ a₂ : M)
Goal: ((fun x => a₁ • x) ∘ fun x => a₂ • x) = fun x => (a₁ * a₂) • x
-- vadd_add_vadd
@[to_additive] -- Porting note: nolint to_additive_doc
lemma smul_mul_smul [Mul α] (r s : M) (x y : α) [IsScalarTower M α α] [SMulCommClass M α α] :
    r • x * s • y = (r * s) • (x * y) 
Arguments: {M : Type u_1} {α : Type u_7} [AddMonoid M] [AddAction M α] [Add α] (r s : M) (x y : α) [VAddAssocClass M α α] [VAddCommClass M α α]
Goal: r +ᵥ x + (s +ᵥ y) = r + s +ᵥ (x + y)
-- smul_mul_smul
@[to_additive] -- Porting note: nolint to_additive_doc
lemma smul_mul_smul [Mul α] (r s : M) (x y : α) [IsScalarTower M α α] [SMulCommClass M α α] :
    r • x * s • y = (r * s) • (x * y) 
Arguments: {M : Type u_1} {α : Type u_7} [Monoid M] [MulAction M α] [Mul α] (r s : M) (x y : α) [IsScalarTower M α α] [SMulCommClass M α α]
Goal: r • x * s • y = (r * s) • (x * y)
-- smul_pow
lemma smul_pow (r : M) (x : N) : ∀ n, (r • x) ^ n = r ^ n • x ^ n
  
Arguments: {M : Type u_1} {N : Type u_2} [Monoid M] [Monoid N] [MulAction M N] [IsScalarTower M N N] [SMulCommClass M N N] (r : M) (x : N) (n : ℕ)
Goal: (r • x) ^ n = r ^ n • x ^ n
-- neg_vadd_vadd
@[to_additive (attr := simp)]
lemma inv_smul_smul (g : G) (a : α) : g⁻¹ • g • a = a 
Arguments: {G : Type u_3} {α : Type u_7} [AddGroup G] [AddAction G α] (g : G) (a : α)
Goal: -g +ᵥ (g +ᵥ a) = a
-- inv_smul_smul
@[to_additive (attr := simp)]
lemma inv_smul_smul (g : G) (a : α) : g⁻¹ • g • a = a 
Arguments: {G : Type u_3} {α : Type u_7} [Group G] [MulAction G α] (g : G) (a : α)
Goal: g⁻¹ • g • a = a
-- vadd_neg_vadd
@[to_additive (attr := simp)]
lemma smul_inv_smul (g : G) (a : α) : g • g⁻¹ • a = a 
Arguments: {G : Type u_3} {α : Type u_7} [AddGroup G] [AddAction G α] (g : G) (a : α)
Goal: g +ᵥ (-g +ᵥ a) = a
-- smul_inv_smul
@[to_additive (attr := simp)]
lemma smul_inv_smul (g : G) (a : α) : g • g⁻¹ • a = a 
Arguments: {G : Type u_3} {α : Type u_7} [Group G] [MulAction G α] (g : G) (a : α)
Goal: g • g⁻¹ • a = a
-- inv_smul_eq_iff
@[to_additive] lemma inv_smul_eq_iff : g⁻¹ • a = b ↔ a = g • b 
Arguments: {G : Type u_3} {α : Type u_7} [Group G] [MulAction G α] {g : G} {a b : α}
Goal: g⁻¹ • a = b ↔ a = g • b
-- neg_vadd_eq_iff
@[to_additive] lemma inv_smul_eq_iff : g⁻¹ • a = b ↔ a = g • b 
Arguments: {G : Type u_3} {α : Type u_7} [AddGroup G] [AddAction G α] {g : G} {a b : α}
Goal: -g +ᵥ a = b ↔ a = g +ᵥ b
-- eq_inv_smul_iff
@[to_additive] lemma eq_inv_smul_iff : a = g⁻¹ • b ↔ g • a = b 
Arguments: {G : Type u_3} {α : Type u_7} [Group G] [MulAction G α] {g : G} {a b : α}
Goal: a = g⁻¹ • b ↔ g • a = b
-- eq_neg_vadd_iff
@[to_additive] lemma eq_inv_smul_iff : a = g⁻¹ • b ↔ g • a = b 
Arguments: {G : Type u_3} {α : Type u_7} [AddGroup G] [AddAction G α] {g : G} {a b : α}
Goal: a = -g +ᵥ b ↔ g +ᵥ a = b
-- Commute.smul_right_iff
@[simp] lemma Commute.smul_right_iff : Commute a (g • b) ↔ Commute a b 
Arguments: {G : Type u_3} {H : Type u_4} [Group G] [Mul H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] {g : G} {a b : H}
Goal: Commute a (g • b) ↔ Commute a b
-- Commute.smul_left_iff
@[simp] lemma Commute.smul_left_iff : Commute (g • a) b ↔ Commute a b 
Arguments: {G : Type u_3} {H : Type u_4} [Group G] [Mul H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] {g : G} {a b : H}
Goal: Commute (g • a) b ↔ Commute a b
-- smul_inv
lemma smul_inv (g : G) (a : H) : (g • a)⁻¹ = g⁻¹ • a⁻¹ 
Arguments: {G : Type u_3} {H : Type u_4} [Group G] [Group H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] (g : G) (a : H)
Goal: (g • a)⁻¹ = g⁻¹ • a⁻¹
-- smul_zpow
lemma smul_zpow (g : G) (a : H) (n : ℤ) : (g • a) ^ n = g ^ n • a ^ n 
Arguments: {G : Type u_3} {H : Type u_4} [Group G] [Group H] [MulAction G H] [SMulCommClass G H H] [IsScalarTower G H H] (g : G) (a : H) (n : ℤ)
Goal: (g • a) ^ n = g ^ n • a ^ n
-- SMulCommClass.of_commMonoid
lemma SMulCommClass.of_commMonoid
    (A B G : Type*) [CommMonoid G] [SMul A G] [SMul B G]
    [IsScalarTower A G G] [IsScalarTower B G G] :
    SMulCommClass A B G 
Arguments: (A : Type u_11) (B : Type u_12) (G : Type u_13) [CommMonoid G] [SMul A G] [SMul B G] [IsScalarTower A G G] [IsScalarTower B G G]
Goal: SMulCommClass A B G
-- MulAction.toFun_apply
@[to_additive (attr := simp)]
lemma toFun_apply (x : M) (y : α) : MulAction.toFun M α y x = x • y 
Arguments: {M : Type u_1} {α : Type u_7} [Monoid M] [MulAction M α] (x : M) (y : α)
Goal: (MulAction.toFun M α) y x = x • y
-- AddAction.toFun_apply
@[to_additive (attr := simp)]
lemma toFun_apply (x : M) (y : α) : MulAction.toFun M α y x = x • y 
Arguments: {M : Type u_1} {α : Type u_7} [AddMonoid M] [AddAction M α] (x : M) (y : α)
Goal: (AddAction.toFun M α) y x = x +ᵥ y
-- AddAction.compHom_vadd_def
@[to_additive]
lemma compHom_smul_def
    {E F G : Type*} [Monoid E] [Monoid F] [MulAction F G] (f : E →* F) (a : E) (x : G) :
    letI : MulAction E G := MulAction.compHom _ f
    a • x = (f a) • x 
Arguments: {E : Type u_11} {F : Type u_12} {G : Type u_13} [AddMonoid E] [AddMonoid F] [AddAction F G] (f : E →+ F) (a : E) (x : G)
Goal: a +ᵥ x = f a +ᵥ x
-- MulAction.compHom_smul_def
@[to_additive]
lemma compHom_smul_def
    {E F G : Type*} [Monoid E] [Monoid F] [MulAction F G] (f : E →* F) (a : E) (x : G) :
    letI : MulAction E G := MulAction.compHom _ f
    a • x = (f a) • x 
Arguments: {E : Type u_11} {F : Type u_12} {G : Type u_13} [Monoid E] [Monoid F] [MulAction F G] (f : E →* F) (a : E) (x : G)
Goal: a • x = f a • x
-- MulAction.isPretransitive_compHom
@[to_additive]
lemma isPretransitive_compHom {E F G : Type*} [Monoid E] [Monoid F] [MulAction F G]
    [IsPretransitive F G] {f : E →* F} (hf : Surjective f) :
    letI : MulAction E G := MulAction.compHom _ f
    IsPretransitive E G 
Arguments: {E : Type u_11} {F : Type u_12} {G : Type u_13} [Monoid E] [Monoid F] [MulAction F G] [MulAction.IsPretransitive F G] {f : E →* F} (hf : Function.Surjective ⇑f)
Goal: MulAction.IsPretransitive E G
-- AddAction.isPretransitive_compHom
@[to_additive]
lemma isPretransitive_compHom {E F G : Type*} [Monoid E] [Monoid F] [MulAction F G]
    [IsPretransitive F G] {f : E →* F} (hf : Surjective f) :
    letI : MulAction E G := MulAction.compHom _ f
    IsPretransitive E G 
Arguments: {E : Type u_11} {F : Type u_12} {G : Type u_13} [AddMonoid E] [AddMonoid F] [AddAction F G] [AddAction.IsPretransitive F G] {f : E →+ F} (hf : Function.Surjective ⇑f)
Goal: AddAction.IsPretransitive E G
-- MulAction.IsPretransitive.of_smul_eq
@[to_additive]
lemma IsPretransitive.of_smul_eq {M N α : Type*} [SMul M α] [SMul N α] [IsPretransitive M α]
    (f : M → N) (hf : ∀ {c : M} {x : α}, f c • x = c • x) : IsPretransitive N α 
Arguments: {M : Type u_11} {N : Type u_12} {α : Type u_13} [SMul M α] [SMul N α] [MulAction.IsPretransitive M α] (f : M → N) (hf : ∀ {c : M} {x : α}, f c • x = c • x)
Goal: MulAction.IsPretransitive N α
-- AddAction.IsPretransitive.of_vadd_eq
@[to_additive]
lemma IsPretransitive.of_smul_eq {M N α : Type*} [SMul M α] [SMul N α] [IsPretransitive M α]
    (f : M → N) (hf : ∀ {c : M} {x : α}, f c • x = c • x) : IsPretransitive N α 
Arguments: {M : Type u_11} {N : Type u_12} {α : Type u_13} [VAdd M α] [VAdd N α] [AddAction.IsPretransitive M α] (f : M → N) (hf : ∀ {c : M} {x : α}, f c +ᵥ x = c +ᵥ x)
Goal: AddAction.IsPretransitive N α
-- AddAction.IsPretransitive.of_compHom
@[to_additive]
lemma IsPretransitive.of_compHom {M N α : Type*} [Monoid M] [Monoid N] [MulAction N α]
    (f : M →* N) [h : letI := compHom α f; IsPretransitive M α] : IsPretransitive N α 
Arguments: {M : Type u_11} {N : Type u_12} {α : Type u_13} [AddMonoid M] [AddMonoid N] [AddAction N α] (f : M →+ N) [h : AddAction.IsPretransitive M α]
Goal: AddAction.IsPretransitive N α
-- MulAction.IsPretransitive.of_compHom
@[to_additive]
lemma IsPretransitive.of_compHom {M N α : Type*} [Monoid M] [Monoid N] [MulAction N α]
    (f : M →* N) [h : letI := compHom α f; IsPretransitive M α] : IsPretransitive N α 
Arguments: {M : Type u_11} {N : Type u_12} {α : Type u_13} [Monoid M] [Monoid N] [MulAction N α] (f : M →* N) [h : MulAction.IsPretransitive M α]
Goal: MulAction.IsPretransitive N α
-- vadd_zero_vadd
@[to_additive]
lemma smul_one_smul {M} (N) [Monoid N] [SMul M N] [MulAction N α] [SMul M α]
    [IsScalarTower M N α] (x : M) (y : α) : (x • (1 : N)) • y = x • y 
Arguments: {α : Type u_7} {M : Type u_11} (N : Type u_12) [AddMonoid N] [VAdd M N] [AddAction N α] [VAdd M α] [VAddAssocClass M N α] (x : M) (y : α)
Goal: x +ᵥ 0 +ᵥ y = x +ᵥ y
-- smul_one_smul
@[to_additive]
lemma smul_one_smul {M} (N) [Monoid N] [SMul M N] [MulAction N α] [SMul M α]
    [IsScalarTower M N α] (x : M) (y : α) : (x • (1 : N)) • y = x • y 
Arguments: {α : Type u_7} {M : Type u_11} (N : Type u_12) [Monoid N] [SMul M N] [MulAction N α] [SMul M α] [IsScalarTower M N α] (x : M) (y : α)
Goal: (x • 1) • y = x • y
-- MulAction.IsPretransitive.of_isScalarTower
@[to_additive]
lemma MulAction.IsPretransitive.of_isScalarTower (M : Type*) {N α : Type*} [Monoid N] [SMul M N]
    [MulAction N α] [SMul M α] [IsScalarTower M N α] [IsPretransitive M α] : IsPretransitive N α 
Arguments: (M : Type u_11) {N : Type u_12} {α : Type u_13} [Monoid N] [SMul M N] [MulAction N α] [SMul M α] [IsScalarTower M N α] [MulAction.IsPretransitive M α]
Goal: MulAction.IsPretransitive N α
-- AddAction.IsPretransitive.of_isScalarTower
@[to_additive]
lemma MulAction.IsPretransitive.of_isScalarTower (M : Type*) {N α : Type*} [Monoid N] [SMul M N]
    [MulAction N α] [SMul M α] [IsScalarTower M N α] [IsPretransitive M α] : IsPretransitive N α 
Arguments: (M : Type u_11) {N : Type u_12} {α : Type u_13} [AddMonoid N] [VAdd M N] [AddAction N α] [VAdd M α] [VAddAssocClass M N α] [AddAction.IsPretransitive M α]
Goal: AddAction.IsPretransitive N α
-- smul_one_mul
@[to_additive (attr := simp)]
lemma smul_one_mul {M N} [MulOneClass N] [SMul M N] [IsScalarTower M N N] (x : M) (y : N) :
    x • (1 : N) * y = x • y 
Arguments: {M : Type u_11} {N : Type u_12} [MulOneClass N] [SMul M N] [IsScalarTower M N N] (x : M) (y : N)
Goal: x • 1 * y = x • y
-- vadd_zero_add
@[to_additive (attr := simp)]
lemma smul_one_mul {M N} [MulOneClass N] [SMul M N] [IsScalarTower M N N] (x : M) (y : N) :
    x • (1 : N) * y = x • y 
Arguments: {M : Type u_11} {N : Type u_12} [AddZeroClass N] [VAdd M N] [VAddAssocClass M N N] (x : M) (y : N)
Goal: x +ᵥ 0 + y = x +ᵥ y
-- mul_smul_one
@[to_additive (attr := simp)]
lemma mul_smul_one {M N} [MulOneClass N] [SMul M N] [SMulCommClass M N N] (x : M) (y : N) :
    y * x • (1 : N) = x • y 
Arguments: {M : Type u_11} {N : Type u_12} [MulOneClass N] [SMul M N] [SMulCommClass M N N] (x : M) (y : N)
Goal: y * x • 1 = x • y
-- add_vadd_zero
@[to_additive (attr := simp)]
lemma mul_smul_one {M N} [MulOneClass N] [SMul M N] [SMulCommClass M N N] (x : M) (y : N) :
    y * x • (1 : N) = x • y 
Arguments: {M : Type u_11} {N : Type u_12} [AddZeroClass N] [VAdd M N] [VAddCommClass M N N] (x : M) (y : N)
Goal: y + (x +ᵥ 0) = x +ᵥ y
-- VAddAssocClass.of_vadd_zero_add
@[to_additive]
lemma IsScalarTower.of_smul_one_mul {M N} [Monoid N] [SMul M N]
    (h : ∀ (x : M) (y : N), x • (1 : N) * y = x • y) : IsScalarTower M N N 
Arguments: {M : Type u_11} {N : Type u_12} [AddMonoid N] [VAdd M N] (h : ∀ (x : M) (y : N), x +ᵥ 0 + y = x +ᵥ y)
Goal: VAddAssocClass M N N
-- IsScalarTower.of_smul_one_mul
@[to_additive]
lemma IsScalarTower.of_smul_one_mul {M N} [Monoid N] [SMul M N]
    (h : ∀ (x : M) (y : N), x • (1 : N) * y = x • y) : IsScalarTower M N N 
Arguments: {M : Type u_11} {N : Type u_12} [Monoid N] [SMul M N] (h : ∀ (x : M) (y : N), x • 1 * y = x • y)
Goal: IsScalarTower M N N
-- VAddCommClass.of_add_vadd_zero
@[to_additive]
lemma SMulCommClass.of_mul_smul_one {M N} [Monoid N] [SMul M N]
    (H : ∀ (x : M) (y : N), y * x • (1 : N) = x • y) : SMulCommClass M N N 
Arguments: {M : Type u_11} {N : Type u_12} [AddMonoid N] [VAdd M N] (H : ∀ (x : M) (y : N), y + (x +ᵥ 0) = x +ᵥ y)
Goal: VAddCommClass M N N
-- SMulCommClass.of_mul_smul_one
@[to_additive]
lemma SMulCommClass.of_mul_smul_one {M N} [Monoid N] [SMul M N]
    (H : ∀ (x : M) (y : N), y * x • (1 : N) = x • y) : SMulCommClass M N N 
Arguments: {M : Type u_11} {N : Type u_12} [Monoid N] [SMul M N] (H : ∀ (x : M) (y : N), y * x • 1 = x • y)
Goal: SMulCommClass M N N
-- MonoidHom.smulOneHom_apply
@[to_additive (attr := simps)
"If the additive action of `M` on `N` is compatible with addition on `N`, then
`fun x ↦ x +ᵥ 0` is an additive monoid homomorphism from `M` to `N`."]
def MonoidHom.smulOneHom {M N} [Monoid M] [MulOneClass N] [MulAction M N] [IsScalarTower M N N] :
    M →* N 
Arguments: {M : Type u_11} {N : Type u_12} [Monoid M] [MulOneClass N] [MulAction M N] [IsScalarTower M N N] (x : M)
Goal: MonoidHom.smulOneHom x = x • 1
-- AddMonoidHom.vaddZeroHom_apply
@[to_additive (attr := simps)
"If the additive action of `M` on `N` is compatible with addition on `N`, then
`fun x ↦ x +ᵥ 0` is an additive monoid homomorphism from `M` to `N`."]
def MonoidHom.smulOneHom {M N} [Monoid M] [MulOneClass N] [MulAction M N] [IsScalarTower M N N] :
    M →* N 
Arguments: {M : Type u_11} {N : Type u_12} [AddMonoid M] [AddZeroClass N] [AddAction M N] [VAddAssocClass M N N] (x : M)
Goal: AddMonoidHom.vaddZeroHom x = x +ᵥ 0
-- Function.End.smul_def
@[simp] lemma Function.End.smul_def (f : Function.End α) (a : α) : f • a = f a 
Arguments: {α : Type u_7} (f : Function.End α) (a : α)
Goal: f • a = f a
-- Function.End.mul_def
lemma Function.End.mul_def (f g : Function.End α) : (f * g) = f ∘ g 
Arguments: {α : Type u_7} (f g : Function.End α)
Goal: f * g = f ∘ g
-- Function.End.one_def
lemma Function.End.one_def : (1 : Function.End α) = id 
Arguments: {α : Type u_7}
Goal: 1 = id
-- toMul_smul
@[simp] lemma toMul_smul [SMul α β] (a) (b : β) : (toMul a : α) • b = a +ᵥ b 
Arguments: {α : Type u_7} {β : Type u_8} [SMul α β] (a : Additive α) (b : β)
Goal: Additive.toMul a • b = a +ᵥ b
-- ofMul_vadd
@[simp] lemma ofMul_vadd [SMul α β] (a : α) (b : β) : ofMul a +ᵥ b = a • b 
Arguments: {α : Type u_7} {β : Type u_8} [SMul α β] (a : α) (b : β)
Goal: Additive.ofMul a +ᵥ b = a • b
-- toAdd_vadd
@[simp] lemma toAdd_vadd [VAdd α β] (a) (b : β) : (toAdd a : α) +ᵥ b = a • b 
Arguments: {α : Type u_7} {β : Type u_8} [VAdd α β] (a : Multiplicative α) (b : β)
Goal: Multiplicative.toAdd a +ᵥ b = a • b
-- ofAdd_smul
@[simp] lemma ofAdd_smul [VAdd α β] (a : α) (b : β) : ofAdd a • b = a +ᵥ b 
Arguments: {α : Type u_7} {β : Type u_8} [VAdd α β] (a : α) (b : β)
Goal: Multiplicative.ofAdd a • b = a +ᵥ b
-- mulLeftEmbedding_apply
@[to_additive (attr := simps)
      "If left-addition by any element is cancellative, left-addition by `g` is an
        embedding."]
def mulLeftEmbedding [Mul G] [IsLeftCancelMul G] (g : G) : G ↪ G 
Arguments: {G : Type u_1} [Mul G] [IsLeftCancelMul G] (g h : G)
Goal: (mulLeftEmbedding g) h = g * h