ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- AddCon.map_of_add_left_rel_zero
@[to_additive "Sometimes, an additive group is defined as a quotient of a monoid
  by an additive congruence relation.
  Usually, the inverse operation is defined as `Setoid.map f _` for some `f`.
  This lemma allows to avoid code duplication in the definition of the inverse operation:
  instead of proving both `∀ x y, c x y → c (f x) (f y)` (to define the operation)
  and `∀ x, c (f x + x) 0` (to prove the group laws), one can only prove the latter."]
theorem map_of_mul_left_rel_one [Monoid M] (c : Con M)
    (f : M → M) (hf : ∀ x, c (f x * x) 1) {x y} (h : c x y) : c (f x) (f y) 
Arguments: {M : Type u_1} [AddMonoid M] (c : AddCon M) (f : M → M) (hf : ∀ (x : M), c (f x + x) 0) {x y : M} (h : c x y)
Goal: c (f x) (f y)
-- Con.map_of_mul_left_rel_one
@[to_additive "Sometimes, an additive group is defined as a quotient of a monoid
  by an additive congruence relation.
  Usually, the inverse operation is defined as `Setoid.map f _` for some `f`.
  This lemma allows to avoid code duplication in the definition of the inverse operation:
  instead of proving both `∀ x y, c x y → c (f x) (f y)` (to define the operation)
  and `∀ x, c (f x + x) 0` (to prove the group laws), one can only prove the latter."]
theorem map_of_mul_left_rel_one [Monoid M] (c : Con M)
    (f : M → M) (hf : ∀ x, c (f x * x) 1) {x y} (h : c x y) : c (f x) (f y) 
Arguments: {M : Type u_1} [Monoid M] (c : Con M) (f : M → M) (hf : ∀ (x : M), c (f x * x) 1) {x y : M} (h : c x y)
Goal: c (f x) (f y)
-- AddCon.neg
@[to_additive "Additive congruence relations preserve negation."]
protected theorem inv {x y} (h : c x y) : c x⁻¹ y⁻¹ 
Arguments: {M : Type u_1} [AddGroup M] (c : AddCon M) {x y : M} (h : c x y)
Goal: c (-x) (-y)
-- Con.inv
@[to_additive "Additive congruence relations preserve negation."]
protected theorem inv {x y} (h : c x y) : c x⁻¹ y⁻¹ 
Arguments: {M : Type u_1} [Group M] (c : Con M) {x y : M} (h : c x y)
Goal: c x⁻¹ y⁻¹
-- Con.div
@[to_additive "Additive congruence relations preserve subtraction."]
protected theorem div : ∀ {w x y z}, c w x → c y z → c (w / y) (x / z) 
Arguments: {M : Type u_1} [Group M] (c : Con M) {w x y z : M}
Goal: c w x → c y z → c (w / y) (x / z)
-- AddCon.sub
@[to_additive "Additive congruence relations preserve subtraction."]
protected theorem div : ∀ {w x y z}, c w x → c y z → c (w / y) (x / z) 
Arguments: {M : Type u_1} [AddGroup M] (c : AddCon M) {w x y z : M}
Goal: c w x → c y z → c (w - y) (x - z)
-- Con.zpow
@[to_additive "Additive congruence relations preserve integer scaling."]
protected theorem zpow : ∀ (n : ℤ) {w x}, c w x → c (w ^ n) (x ^ n)
  
Arguments: {M : Type u_1} [Group M] (c : Con M) (n : ℤ) {w x : M}
Goal: c w x → c (w ^ n) (x ^ n)
-- AddCon.zsmul
@[to_additive "Additive congruence relations preserve integer scaling."]
protected theorem zpow : ∀ (n : ℤ) {w x}, c w x → c (w ^ n) (x ^ n)
  
Arguments: {M : Type u_1} [AddGroup M] (c : AddCon M) (n : ℤ) {w x : M}
Goal: c w x → c (n • w) (n • x)
-- Con.liftOnUnits_mk
@[to_additive (attr := simp)]
theorem liftOnUnits_mk (f : ∀ x y : M, c (x * y) 1 → c (y * x) 1 → α)
    (Hf : ∀ x y hxy hyx x' y' hxy' hyx', c x x' → c y y' → f x y hxy hyx = f x' y' hxy' hyx')
    (x y : M) (hxy hyx) :
    liftOnUnits ⟨(x : c.Quotient), y, hxy, hyx⟩ f Hf = f x y (c.eq.1 hxy) (c.eq.1 hyx) 
Arguments: {M : Type u_1} {α : Type u_4} [Monoid M] {c : Con M} (f : (x y : M) → c (x * y) 1 → c (y * x) 1 → α) (Hf :
  ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1) (x' y' : M) (hxy' : c (x' * y') 1) (hyx' : c (y' * x') 1),
    c x x' → c y y' → f x y hxy hyx = f x' y' hxy' hyx') (x y : M) (hxy : ↑x * ↑y = 1) (hyx : ↑y * ↑x = 1)
Goal: Con.liftOnUnits { val := ↑x, inv := ↑y, val_inv := hxy, inv_val := hyx } f Hf = f x y ⋯ ⋯
-- AddCon.liftOnAddUnits_mk
@[to_additive (attr := simp)]
theorem liftOnUnits_mk (f : ∀ x y : M, c (x * y) 1 → c (y * x) 1 → α)
    (Hf : ∀ x y hxy hyx x' y' hxy' hyx', c x x' → c y y' → f x y hxy hyx = f x' y' hxy' hyx')
    (x y : M) (hxy hyx) :
    liftOnUnits ⟨(x : c.Quotient), y, hxy, hyx⟩ f Hf = f x y (c.eq.1 hxy) (c.eq.1 hyx) 
Arguments: {M : Type u_1} {α : Type u_4} [AddMonoid M] {c : AddCon M} (f : (x y : M) → c (x + y) 0 → c (y + x) 0 → α) (Hf :
  ∀ (x y : M) (hxy : c (x + y) 0) (hyx : c (y + x) 0) (x' y' : M) (hxy' : c (x' + y') 0) (hyx' : c (y' + x') 0),
    c x x' → c y y' → f x y hxy hyx = f x' y' hxy' hyx') (x y : M) (hxy : ↑x + ↑y = 0) (hyx : ↑y + ↑x = 0)
Goal: AddCon.liftOnAddUnits { val := ↑x, neg := ↑y, val_neg := hxy, neg_val := hyx } f Hf = f x y ⋯ ⋯
-- AddCon.induction_on_addUnits
@[to_additive (attr := elab_as_elim)]
theorem induction_on_units {p : Units c.Quotient → Prop} (u : Units c.Quotient)
    (H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p ⟨x, y, c.eq.2 hxy, c.eq.2 hyx⟩) :
    p u 
Arguments: {M : Type u_1} [AddMonoid M] {c : AddCon M} {p : AddUnits c.Quotient → Prop} (u : AddUnits c.Quotient) (H : ∀ (x y : M) (hxy : c (x + y) 0) (hyx : c (y + x) 0), p { val := ↑x, neg := ↑y, val_neg := ⋯, neg_val := ⋯ })
Goal: p u
-- Con.induction_on_units
@[to_additive (attr := elab_as_elim)]
theorem induction_on_units {p : Units c.Quotient → Prop} (u : Units c.Quotient)
    (H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p ⟨x, y, c.eq.2 hxy, c.eq.2 hyx⟩) :
    p u 
Arguments: {M : Type u_1} [Monoid M] {c : Con M} {p : c.Quotientˣ → Prop} (u : c.Quotientˣ) (H : ∀ (x y : M) (hxy : c (x * y) 1) (hyx : c (y * x) 1), p { val := ↑x, inv := ↑y, val_inv := ⋯, inv_val := ⋯ })
Goal: p u
-- Con.coe_smul
@[to_additive]
theorem coe_smul {α M : Type*} [MulOneClass M] [SMul α M] [IsScalarTower α M M] (c : Con M)
    (a : α) (x : M) : (↑(a • x) : c.Quotient) = a • (x : c.Quotient) 
Arguments: {α : Type u_4} {M : Type u_5} [MulOneClass M] [SMul α M] [IsScalarTower α M M] (c : Con M) (a : α) (x : M)
Goal: ↑(a • x) = a • ↑x
-- AddCon.coe_vadd
@[to_additive]
theorem coe_smul {α M : Type*} [MulOneClass M] [SMul α M] [IsScalarTower α M M] (c : Con M)
    (a : α) (x : M) : (↑(a • x) : c.Quotient) = a • (x : c.Quotient) 
Arguments: {α : Type u_4} {M : Type u_5} [AddZeroClass M] [VAdd α M] [VAddAssocClass α M M] (c : AddCon M) (a : α) (x : M)
Goal: ↑(a +ᵥ x) = a +ᵥ ↑x
-- DomMulAct.smul_mulActionHom_apply
theorem smul_mulActionHom_apply (c : Mᵈᵐᵃ) (f : α →[N] β) (a : α) :
    (c • f) a = f (mk.symm c • a) 
Arguments: {M : Type u_1} {α : Type u_2} {N : Type u_3} {β : Type u_4} [SMul M α] [SMul N α] [SMulCommClass M N α] [SMul N β] (c : Mᵈᵐᵃ) (f : α →ₑ[id] β) (a : α)
Goal: (c • f) a = f (DomMulAct.mk.symm c • a)
-- DomMulAct.mk_smul_mulActionHom_apply
@[simp]
theorem mk_smul_mulActionHom_apply (c : M) (f : α →[N] β) (a : α) : (mk c • f) a = f (c • a) 
Arguments: {M : Type u_1} {α : Type u_2} {N : Type u_3} {β : Type u_4} [SMul M α] [SMul N α] [SMulCommClass M N α] [SMul N β] (c : M) (f : α →ₑ[id] β) (a : α)
Goal: (DomMulAct.mk c • f) a = f (c • a)
-- DomMulAct.smul_mulDistribActionHom_apply
theorem smul_mulDistribActionHom_apply (c : Mᵈᵐᵃ) (f : A →+[N] B) (a : A) :
    (c • f) a = f (mk.symm c • a) 
Arguments: {M : Type u_1} {N : Type u_2} {A : Type u_3} {B : Type u_4} [AddMonoid A] [DistribSMul M A] [Monoid N] [AddMonoid B] [DistribMulAction N A] [SMulCommClass M N A] [DistribMulAction N B] (c : Mᵈᵐᵃ) (f : A →+[N] B) (a : A)
Goal: (c • f) a = f (DomMulAct.mk.symm c • a)
-- DomMulAct.mk_smul_mulDistribActionHom_apply
@[simp]
theorem mk_smul_mulDistribActionHom_apply (c : M) (f : A →+[N] B) (a : A) :
    (mk c • f) a = f (c • a) 
Arguments: {M : Type u_1} {N : Type u_2} {A : Type u_3} {B : Type u_4} [AddMonoid A] [DistribSMul M A] [Monoid N] [AddMonoid B] [DistribMulAction N A] [SMulCommClass M N A] [DistribMulAction N B] (c : M) (f : A →+[N] B) (a : A)
Goal: (DomMulAct.mk c • f) a = f (c • a)
-- DomAddAct.mk_zero
@[to_additive (attr := simp)]
lemma mk_one [One M] : mk (1 : M) = 1 
Arguments: {M : Type u_1} [Zero M]
Goal: DomAddAct.mk 0 = 0
-- DomMulAct.mk_one
@[to_additive (attr := simp)]
lemma mk_one [One M] : mk (1 : M) = 1 
Arguments: {M : Type u_1} [One M]
Goal: DomMulAct.mk 1 = 1
-- DomAddAct.symm_mk_zero
@[to_additive (attr := simp)]
lemma symm_mk_one [One M] : mk.symm (1 : Mᵈᵐᵃ) = 1 
Arguments: {M : Type u_1} [Zero M]
Goal: DomAddAct.mk.symm 0 = 0
-- DomMulAct.symm_mk_one
@[to_additive (attr := simp)]
lemma symm_mk_one [One M] : mk.symm (1 : Mᵈᵐᵃ) = 1 
Arguments: {M : Type u_1} [One M]
Goal: DomMulAct.mk.symm 1 = 1
-- DomAddAct.mk_add
@[to_additive (attr := simp)]
lemma mk_mul [Mul M] (a b : M) : mk (a * b) = mk b * mk a 
Arguments: {M : Type u_1} [Add M] (a b : M)
Goal: DomAddAct.mk (a + b) = DomAddAct.mk b + DomAddAct.mk a
-- DomMulAct.mk_mul
@[to_additive (attr := simp)]
lemma mk_mul [Mul M] (a b : M) : mk (a * b) = mk b * mk a 
Arguments: {M : Type u_1} [Mul M] (a b : M)
Goal: DomMulAct.mk (a * b) = DomMulAct.mk b * DomMulAct.mk a
-- DomAddAct.symm_mk_add
@[to_additive (attr := simp)]
lemma symm_mk_mul [Mul M] (a b : Mᵈᵐᵃ) : mk.symm (a * b) = mk.symm b * mk.symm a 
Arguments: {M : Type u_1} [Add M] (a b : Mᵈᵃᵃ)
Goal: DomAddAct.mk.symm (a + b) = DomAddAct.mk.symm b + DomAddAct.mk.symm a
-- DomMulAct.symm_mk_mul
@[to_additive (attr := simp)]
lemma symm_mk_mul [Mul M] (a b : Mᵈᵐᵃ) : mk.symm (a * b) = mk.symm b * mk.symm a 
Arguments: {M : Type u_1} [Mul M] (a b : Mᵈᵐᵃ)
Goal: DomMulAct.mk.symm (a * b) = DomMulAct.mk.symm b * DomMulAct.mk.symm a
-- DomAddAct.mk_neg
@[to_additive (attr := simp)]
lemma mk_inv [Inv M] (a : M) : mk (a⁻¹) = (mk a)⁻¹ 
Arguments: {M : Type u_1} [Neg M] (a : M)
Goal: DomAddAct.mk (-a) = -DomAddAct.mk a
-- DomMulAct.mk_inv
@[to_additive (attr := simp)]
lemma mk_inv [Inv M] (a : M) : mk (a⁻¹) = (mk a)⁻¹ 
Arguments: {M : Type u_1} [Inv M] (a : M)
Goal: DomMulAct.mk a⁻¹ = (DomMulAct.mk a)⁻¹
-- DomMulAct.symm_mk_inv
@[to_additive (attr := simp)]
lemma symm_mk_inv [Inv M] (a : Mᵈᵐᵃ) : mk.symm (a⁻¹) = (mk.symm a)⁻¹ 
Arguments: {M : Type u_1} [Inv M] (a : Mᵈᵐᵃ)
Goal: DomMulAct.mk.symm a⁻¹ = (DomMulAct.mk.symm a)⁻¹
-- DomAddAct.symm_mk_neg
@[to_additive (attr := simp)]
lemma symm_mk_inv [Inv M] (a : Mᵈᵐᵃ) : mk.symm (a⁻¹) = (mk.symm a)⁻¹ 
Arguments: {M : Type u_1} [Neg M] (a : Mᵈᵃᵃ)
Goal: DomAddAct.mk.symm (-a) = -DomAddAct.mk.symm a
-- DomMulAct.mk_pow
@[to_additive (attr := simp)]
lemma mk_pow [Monoid M] (a : M) (n : ℕ) : mk (a ^ n) = mk a ^ n 
Arguments: {M : Type u_1} [Monoid M] (a : M) (n : ℕ)
Goal: DomMulAct.mk (a ^ n) = DomMulAct.mk a ^ n
-- DomAddAct.mk_nsmul
@[to_additive (attr := simp)]
lemma mk_pow [Monoid M] (a : M) (n : ℕ) : mk (a ^ n) = mk a ^ n 
Arguments: {M : Type u_1} [AddMonoid M] (a : M) (n : ℕ)
Goal: DomAddAct.mk (n • a) = n • DomAddAct.mk a
-- DomMulAct.symm_mk_pow
@[to_additive (attr := simp)]
lemma symm_mk_pow [Monoid M] (a : Mᵈᵐᵃ) (n : ℕ) : mk.symm (a ^ n) = mk.symm a ^ n 
Arguments: {M : Type u_1} [Monoid M] (a : Mᵈᵐᵃ) (n : ℕ)
Goal: DomMulAct.mk.symm (a ^ n) = DomMulAct.mk.symm a ^ n
-- DomAddAct.symm_mk_nsmul
@[to_additive (attr := simp)]
lemma symm_mk_pow [Monoid M] (a : Mᵈᵐᵃ) (n : ℕ) : mk.symm (a ^ n) = mk.symm a ^ n 
Arguments: {M : Type u_1} [AddMonoid M] (a : Mᵈᵃᵃ) (n : ℕ)
Goal: DomAddAct.mk.symm (n • a) = n • DomAddAct.mk.symm a
-- DomMulAct.mk_zpow
@[to_additive (attr := simp)]
lemma mk_zpow [DivInvMonoid M] (a : M) (n : ℤ) : mk (a ^ n) = mk a ^ n 
Arguments: {M : Type u_1} [DivInvMonoid M] (a : M) (n : ℤ)
Goal: DomMulAct.mk (a ^ n) = DomMulAct.mk a ^ n
-- DomAddAct.mk_zsmul
@[to_additive (attr := simp)]
lemma mk_zpow [DivInvMonoid M] (a : M) (n : ℤ) : mk (a ^ n) = mk a ^ n 
Arguments: {M : Type u_1} [SubNegMonoid M] (a : M) (n : ℤ)
Goal: DomAddAct.mk (n • a) = n • DomAddAct.mk a
-- DomMulAct.symm_mk_zpow
@[to_additive (attr := simp)]
lemma symm_mk_zpow [DivInvMonoid M] (a : Mᵈᵐᵃ) (n : ℤ) : mk.symm (a ^ n) = mk.symm a ^ n 
Arguments: {M : Type u_1} [DivInvMonoid M] (a : Mᵈᵐᵃ) (n : ℤ)
Goal: DomMulAct.mk.symm (a ^ n) = DomMulAct.mk.symm a ^ n
-- DomAddAct.symm_mk_zsmul
@[to_additive (attr := simp)]
lemma symm_mk_zpow [DivInvMonoid M] (a : Mᵈᵐᵃ) (n : ℤ) : mk.symm (a ^ n) = mk.symm a ^ n 
Arguments: {M : Type u_1} [SubNegMonoid M] (a : Mᵈᵃᵃ) (n : ℤ)
Goal: DomAddAct.mk.symm (n • a) = n • DomAddAct.mk.symm a
-- DomAddAct.vadd_apply
@[to_additive]
theorem smul_apply [SMul M α] (c : Mᵈᵐᵃ) (f : α → β) (a : α) : (c • f) a = f (mk.symm c • a) 
Arguments: {M : Type u_1} {β : Type u_2} {α : Type u_3} [VAdd M α] (c : Mᵈᵃᵃ) (f : α → β) (a : α)
Goal: (c +ᵥ f) a = f (DomAddAct.mk.symm c +ᵥ a)
-- DomMulAct.smul_apply
@[to_additive]
theorem smul_apply [SMul M α] (c : Mᵈᵐᵃ) (f : α → β) (a : α) : (c • f) a = f (mk.symm c • a) 
Arguments: {M : Type u_1} {β : Type u_2} {α : Type u_3} [SMul M α] (c : Mᵈᵐᵃ) (f : α → β) (a : α)
Goal: (c • f) a = f (DomMulAct.mk.symm c • a)
-- DomMulAct.smul_monoidHom_apply
theorem smul_monoidHom_apply (c : Mᵈᵐᵃ) (f : A →* B) (a : A) : (c • f) a = f (mk.symm c • a) 
Arguments: {M : Type u_5} {A : Type u_7} {B : Type u_8} [Monoid M] [Monoid A] [MulDistribMulAction M A] [MulOneClass B] (c : Mᵈᵐᵃ) (f : A →* B) (a : A)
Goal: (c • f) a = f (DomMulAct.mk.symm c • a)
-- DomMulAct.mk_smul_monoidHom_apply
@[simp]
theorem mk_smul_monoidHom_apply (c : M) (f : A →* B) (a : A) : (mk c • f) a = f (c • a) 
Arguments: {M : Type u_5} {A : Type u_7} {B : Type u_8} [Monoid M] [Monoid A] [MulDistribMulAction M A] [MulOneClass B] (c : M) (f : A →* B) (a : A)
Goal: (DomMulAct.mk c • f) a = f (c • a)
-- DomMulAct.smul_addMonoidHom_apply
theorem smul_addMonoidHom_apply (c : Mᵈᵐᵃ) (f : A →+ B) (a : A) : (c • f) a = f (mk.symm c • a) 
Arguments: {A : Type u_5} {B : Type u_6} {M : Type u_7} [AddMonoid A] [DistribSMul M A] [AddZeroClass B] (c : Mᵈᵐᵃ) (f : A →+ B) (a : A)
Goal: (c • f) a = f (DomMulAct.mk.symm c • a)
-- DomMulAct.mk_smul_addMonoidHom_apply
@[simp]
theorem mk_smul_addMonoidHom_apply (c : M) (f : A →+ B) (a : A) : (mk c • f) a = f (c • a) 
Arguments: {A : Type u_5} {B : Type u_6} {M : Type u_7} [AddMonoid A] [DistribSMul M A] [AddZeroClass B] (c : M) (f : A →+ B) (a : A)
Goal: (DomMulAct.mk c • f) a = f (c • a)
-- DomMulAct.coe_smul_addMonoidHom
theorem coe_smul_addMonoidHom (c : Mᵈᵐᵃ) (f : A →+ B) : ⇑(c • f) = c • ⇑f 
Arguments: {A : Type u_5} {B : Type u_6} {M : Type u_7} [AddMonoid A] [DistribSMul M A] [AddZeroClass B] (c : Mᵈᵐᵃ) (f : A →+ B)
Goal: ⇑(c • f) = c • ⇑f
-- IterateAddAct.mk_vadd
@[to_additive (attr := simp)]
theorem mk_smul (n : ℕ) (x : α) : mk (f := f) n • x = f^[n] x 
Arguments: {α : Type u_1} {f : α → α} (n : ℕ) (x : α)
Goal: { val := n } +ᵥ x = f^[n] x
-- IterateMulAct.mk_smul
@[to_additive (attr := simp)]
theorem mk_smul (n : ℕ) (x : α) : mk (f := f) n • x = f^[n] x 
Arguments: {α : Type u_1} {f : α → α} (n : ℕ) (x : α)
Goal: { val := n } • x = f^[n] x
-- inv_smul_smul₀
@[simp]
theorem inv_smul_smul₀ {c : α} (hc : c ≠ 0) (x : β) : c⁻¹ • c • x = x 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {c : α} (hc : c ≠ 0) (x : β)
Goal: c⁻¹ • c • x = x
-- smul_inv_smul₀
@[simp]
theorem smul_inv_smul₀ {c : α} (hc : c ≠ 0) (x : β) : c • c⁻¹ • x = x 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {c : α} (hc : c ≠ 0) (x : β)
Goal: c • c⁻¹ • x = x
-- inv_smul_eq_iff₀
theorem inv_smul_eq_iff₀ {a : α} (ha : a ≠ 0) {x y : β} : a⁻¹ • x = y ↔ x = a • y 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {a : α} (ha : a ≠ 0) {x y : β}
Goal: a⁻¹ • x = y ↔ x = a • y
-- eq_inv_smul_iff₀
theorem eq_inv_smul_iff₀ {a : α} (ha : a ≠ 0) {x y : β} : x = a⁻¹ • y ↔ a • x = y 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {a : α} (ha : a ≠ 0) {x y : β}
Goal: x = a⁻¹ • y ↔ a • x = y
-- Commute.smul_right_iff₀
@[simp]
theorem Commute.smul_right_iff₀ [Mul β] [SMulCommClass α β β] [IsScalarTower α β β] {a b : β}
    {c : α} (hc : c ≠ 0) : Commute a (c • b) ↔ Commute a b 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] [Mul β] [SMulCommClass α β β] [IsScalarTower α β β] {a b : β} {c : α} (hc : c ≠ 0)
Goal: Commute a (c • b) ↔ Commute a b
-- Commute.smul_left_iff₀
@[simp]
theorem Commute.smul_left_iff₀ [Mul β] [SMulCommClass α β β] [IsScalarTower α β β] {a b : β} {c : α}
    (hc : c ≠ 0) : Commute (c • a) b ↔ Commute a b 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] [Mul β] [SMulCommClass α β β] [IsScalarTower α β β] {a b : β} {c : α} (hc : c ≠ 0)
Goal: Commute (c • a) b ↔ Commute a b
-- Equiv.smulRight_apply
@[simps] def Equiv.smulRight (ha : a ≠ 0) : β ≃ β 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {a : α} (ha : a ≠ 0) (b : β)
Goal: (Equiv.smulRight ha) b = a • b
-- Equiv.smulRight_symm_apply
@[simps] def Equiv.smulRight (ha : a ≠ 0) : β ≃ β 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {a : α} (ha : a ≠ 0) (b : β)
Goal: (Equiv.smulRight ha).symm b = a⁻¹ • b
-- MulAction.bijective₀
protected theorem MulAction.bijective₀ (ha : a ≠ 0) : Function.Bijective (a • · : β → β) 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {a : α} (ha : a ≠ 0)
Goal: Function.Bijective fun x => a • x
-- MulAction.injective₀
protected theorem MulAction.injective₀ (ha : a ≠ 0) : Function.Injective (a • · : β → β) 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {a : α} (ha : a ≠ 0)
Goal: Function.Injective fun x => a • x
-- MulAction.surjective₀
protected theorem MulAction.surjective₀ (ha : a ≠ 0) : Function.Surjective (a • · : β → β) 
Arguments: {α : Type u} {β : Type v} [GroupWithZero α] [MulAction α β] {a : α} (ha : a ≠ 0)
Goal: Function.Surjective fun x => a • x
-- DistribMulAction.toAddEquiv_symm_apply
@[simps (config := { simpRhs := true })]
def DistribMulAction.toAddEquiv (x : α) : β ≃+ β 
Arguments: {α : Type u} (β : Type v) [Group α] [AddMonoid β] [DistribMulAction α β] (x : α)
Goal: ∀ (a : β), (DistribMulAction.toAddEquiv β x).symm a = x⁻¹ • a
-- DistribMulAction.toAddEquiv_apply
@[simps (config := { simpRhs := true })]
def DistribMulAction.toAddEquiv (x : α) : β ≃+ β 
Arguments: {α : Type u} (β : Type v) [Group α] [AddMonoid β] [DistribMulAction α β] (x : α)
Goal: ∀ (a : β), (DistribMulAction.toAddEquiv β x) a = x • a
-- DistribMulAction.toAddAut_apply
@[simps]
def DistribMulAction.toAddAut : α →* AddAut β 
Arguments: (α : Type u) (β : Type v) [Group α] [AddMonoid β] [DistribMulAction α β] (x : α)
Goal: (DistribMulAction.toAddAut α β) x = DistribMulAction.toAddEquiv β x
-- smul_eq_zero_iff_eq
theorem smul_eq_zero_iff_eq (a : α) {x : β} : a • x = 0 ↔ x = 0 
Arguments: {α : Type u} {β : Type v} [Group α] [AddMonoid β] [DistribMulAction α β] (a : α) {x : β}
Goal: a • x = 0 ↔ x = 0
-- smul_ne_zero_iff_ne
theorem smul_ne_zero_iff_ne (a : α) {x : β} : a • x ≠ 0 ↔ x ≠ 0 
Arguments: {α : Type u} {β : Type v} [Group α] [AddMonoid β] [DistribMulAction α β] (a : α) {x : β}
Goal: a • x ≠ 0 ↔ x ≠ 0
-- MulDistribMulAction.toMulEquiv_apply
@[simps (config := { simpRhs := true })]
def MulDistribMulAction.toMulEquiv (x : α) : β ≃* β 
Arguments: {α : Type u} (β : Type v) [Group α] [Monoid β] [MulDistribMulAction α β] (x : α)
Goal: ∀ (a : β), (MulDistribMulAction.toMulEquiv β x) a = x • a
-- MulDistribMulAction.toMulEquiv_symm_apply
@[simps (config := { simpRhs := true })]
def MulDistribMulAction.toMulEquiv (x : α) : β ≃* β 
Arguments: {α : Type u} (β : Type v) [Group α] [Monoid β] [MulDistribMulAction α β] (x : α)
Goal: ∀ (a : β), (MulDistribMulAction.toMulEquiv β x).symm a = x⁻¹ • a
-- MulDistribMulAction.toMulAut_apply
@[simps]
def MulDistribMulAction.toMulAut : α →* MulAut β 
Arguments: (α : Type u) (β : Type v) [Group α] [Monoid β] [MulDistribMulAction α β] (x : α)
Goal: (MulDistribMulAction.toMulAut α β) x = MulDistribMulAction.toMulEquiv β x
-- mulAutArrow_apply_symm_apply
@[simps!]
def mulAutArrow {G A H} [Group G] [MulAction G A] [Monoid H] : G →* MulAut (A → H) 
Arguments: {G : Type u_1} {A : Type u_2} {H : Type u_3} [Group G] [MulAction G A] [Monoid H] (x : G)
Goal: ∀ (a : A → H) (a_1 : A), (MulEquiv.symm (mulAutArrow x)) a a_1 = (x⁻¹ • a) a_1
-- mulAutArrow_apply_apply
@[simps!]
def mulAutArrow {G A H} [Group G] [MulAction G A] [Monoid H] : G →* MulAut (A → H) 
Arguments: {G : Type u_1} {A : Type u_2} {H : Type u_3} [Group G] [MulAction G A] [Monoid H] (x : G)
Goal: ∀ (a : A → H) (a_1 : A), (mulAutArrow x) a a_1 = (x • a) a_1
-- IsUnit.smul_eq_zero
@[simp]
theorem smul_eq_zero {u : α} (hu : IsUnit u) {x : β} : u • x = 0 ↔ x = 0 
Arguments: {α : Type u} {β : Type v} [Monoid α] [AddMonoid β] [DistribMulAction α β] {u : α} (hu : IsUnit u) {x : β}
Goal: u • x = 0 ↔ x = 0
-- IsUnit.smul_sub_iff_sub_inv_smul
theorem IsUnit.smul_sub_iff_sub_inv_smul [AddGroup β] [DistribMulAction α β] [IsScalarTower α β β]
    [SMulCommClass α β β] (r : α) (a : β) : IsUnit (r • (1 : β) - a) ↔ IsUnit (1 - r⁻¹ • a) 
Arguments: {α : Type u} {β : Type v} [Group α] [Monoid β] [AddGroup β] [DistribMulAction α β] [IsScalarTower α β β] [SMulCommClass α β β] (r : α) (a : β)
Goal: IsUnit (r • 1 - a) ↔ IsUnit (1 - r⁻¹ • a)
-- mem_fixingSubmonoid_iff
theorem mem_fixingSubmonoid_iff {s : Set α} {m : M} :
    m ∈ fixingSubmonoid M s ↔ ∀ y ∈ s, m • y = y 
Arguments: (M : Type u_1) {α : Type u_2} [Monoid M] [MulAction M α] {s : Set α} {m : M}
Goal: m ∈ fixingSubmonoid M s ↔ ∀ y ∈ s, m • y = y
-- fixingSubmonoid_fixedPoints_gc
theorem fixingSubmonoid_fixedPoints_gc :
    GaloisConnection (OrderDual.toDual ∘ fixingSubmonoid M)
      ((fun P : Submonoid M => fixedPoints P α) ∘ OrderDual.ofDual) 
Arguments: (M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α]
Goal: GaloisConnection (⇑OrderDual.toDual ∘ fixingSubmonoid M) ((fun P => MulAction.fixedPoints (↥P) α) ∘ ⇑OrderDual.ofDual)
-- fixingSubmonoid_antitone
theorem fixingSubmonoid_antitone : Antitone fun s : Set α => fixingSubmonoid M s 
Arguments: (M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α]
Goal: Antitone fun s => fixingSubmonoid M s
-- fixedPoints_antitone
theorem fixedPoints_antitone : Antitone fun P : Submonoid M => fixedPoints P α 
Arguments: (M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α]
Goal: Antitone fun P => MulAction.fixedPoints (↥P) α
-- fixingSubmonoid_union
theorem fixingSubmonoid_union {s t : Set α} :
    fixingSubmonoid M (s ∪ t) = fixingSubmonoid M s ⊓ fixingSubmonoid M t 
Arguments: (M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α] {s t : Set α}
Goal: fixingSubmonoid M (s ∪ t) = fixingSubmonoid M s ⊓ fixingSubmonoid M t
-- fixingSubmonoid_iUnion
theorem fixingSubmonoid_iUnion {ι : Sort*} {s : ι → Set α} :
    fixingSubmonoid M (⋃ i, s i) = ⨅ i, fixingSubmonoid M (s i) 
Arguments: (M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α] {ι : Sort u_3} {s : ι → Set α}
Goal: fixingSubmonoid M (⋃ i, s i) = ⨅ i, fixingSubmonoid M (s i)
-- fixedPoints_submonoid_sup
theorem fixedPoints_submonoid_sup {P Q : Submonoid M} :
    fixedPoints (↥(P ⊔ Q)) α = fixedPoints P α ∩ fixedPoints Q α 
Arguments: (M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α] {P Q : Submonoid M}
Goal: MulAction.fixedPoints (↥(P ⊔ Q)) α = MulAction.fixedPoints (↥P) α ∩ MulAction.fixedPoints (↥Q) α
-- fixedPoints_submonoid_iSup
theorem fixedPoints_submonoid_iSup {ι : Sort*} {P : ι → Submonoid M} :
    fixedPoints (↥(iSup P)) α = ⋂ i, fixedPoints (P i) α 
Arguments: (M : Type u_1) (α : Type u_2) [Monoid M] [MulAction M α] {ι : Sort u_3} {P : ι → Submonoid M}
Goal: MulAction.fixedPoints (↥(iSup P)) α = ⋂ i, MulAction.fixedPoints (↥(P i)) α
-- mem_fixingSubgroup_iff
theorem mem_fixingSubgroup_iff {s : Set α} {m : M} : m ∈ fixingSubgroup M s ↔ ∀ y ∈ s, m • y = y 
Arguments: (M : Type u_1) {α : Type u_2} [Group M] [MulAction M α] {s : Set α} {m : M}
Goal: m ∈ fixingSubgroup M s ↔ ∀ y ∈ s, m • y = y
-- mem_fixingSubgroup_iff_subset_fixedBy
theorem mem_fixingSubgroup_iff_subset_fixedBy {s : Set α} {m : M} :
    m ∈ fixingSubgroup M s ↔ s ⊆ fixedBy α m 
Arguments: (M : Type u_1) {α : Type u_2} [Group M] [MulAction M α] {s : Set α} {m : M}
Goal: m ∈ fixingSubgroup M s ↔ s ⊆ MulAction.fixedBy α m
-- mem_fixingSubgroup_compl_iff_movedBy_subset
theorem mem_fixingSubgroup_compl_iff_movedBy_subset {s : Set α} {m : M} :
    m ∈ fixingSubgroup M sᶜ ↔ (fixedBy α m)ᶜ ⊆ s 
Arguments: (M : Type u_1) {α : Type u_2} [Group M] [MulAction M α] {s : Set α} {m : M}
Goal: m ∈ fixingSubgroup M sᶜ ↔ (MulAction.fixedBy α m)ᶜ ⊆ s