ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- monoidEndToAdditive_apply_apply
@[simps!] def monoidEndToAdditive (M : Type*) [MulOneClass M] :
    Monoid.End M ≃* AddMonoid.End (Additive M) 
Arguments: (M : Type u_3) [MulOneClass M] (f : M →* M) (a : Additive M)
Goal: ((monoidEndToAdditive M) f) a = Additive.ofMul (f (Additive.toMul a))
-- monoidEndToAdditive_symm_apply_apply
@[simps!] def monoidEndToAdditive (M : Type*) [MulOneClass M] :
    Monoid.End M ≃* AddMonoid.End (Additive M) 
Arguments: (M : Type u_3) [MulOneClass M] (f : Additive M →+ Additive M) (a : M)
Goal: ((monoidEndToAdditive M).symm f) a = Additive.toMul (f (Additive.ofMul a))
-- addMonoidEndToMultiplicative_symm_apply_apply
@[simps!] def addMonoidEndToMultiplicative (A : Type*) [AddZeroClass A] :
    AddMonoid.End A ≃* Monoid.End (Multiplicative A) 
Arguments: (A : Type u_3) [AddZeroClass A] (f : Multiplicative A →* Multiplicative A) (a : A)
Goal: ((addMonoidEndToMultiplicative A).symm f) a = Multiplicative.toAdd (f (Multiplicative.ofAdd a))
-- addMonoidEndToMultiplicative_apply_apply
@[simps!] def addMonoidEndToMultiplicative (A : Type*) [AddZeroClass A] :
    AddMonoid.End A ≃* Monoid.End (Multiplicative A) 
Arguments: (A : Type u_3) [AddZeroClass A] (f : A →+ A) (a : Multiplicative A)
Goal: ((addMonoidEndToMultiplicative A) f) a = Multiplicative.ofAdd (f (Multiplicative.toAdd a))
-- AddEquiv.additiveMultiplicative_apply
@[simps!]
def AddEquiv.additiveMultiplicative [AddZeroClass G] : Additive (Multiplicative G) ≃+ G 
Arguments: (G : Type u_1) [AddZeroClass G] (a : Additive (Multiplicative G))
Goal: (AddEquiv.additiveMultiplicative G) a = Multiplicative.toAdd (Additive.toMul a)
-- AddEquiv.additiveMultiplicative_symm_apply
@[simps!]
def AddEquiv.additiveMultiplicative [AddZeroClass G] : Additive (Multiplicative G) ≃+ G 
Arguments: (G : Type u_1) [AddZeroClass G] (a : G)
Goal: (AddEquiv.additiveMultiplicative G).symm a = Additive.ofMul (Multiplicative.ofAdd a)
-- MulEquiv.multiplicativeAdditive_apply
@[simps!]
def MulEquiv.multiplicativeAdditive [MulOneClass H] : Multiplicative (Additive H) ≃* H 
Arguments: (H : Type u_2) [MulOneClass H] (a : Multiplicative (Additive H))
Goal: (MulEquiv.multiplicativeAdditive H) a = Additive.toMul (Multiplicative.toAdd a)
-- MulEquiv.multiplicativeAdditive_symm_apply
@[simps!]
def MulEquiv.multiplicativeAdditive [MulOneClass H] : Multiplicative (Additive H) ≃* H 
Arguments: (H : Type u_2) [MulOneClass H] (a : H)
Goal: (MulEquiv.multiplicativeAdditive H).symm a = Multiplicative.ofAdd (Additive.ofMul a)
-- NatPowAssoc.npow_one
class NatPowAssoc (M : Type*) [MulOneClass M] [Pow M ℕ] : Prop where
    protected npow_add : ∀ (k n : ℕ) (x : M), x ^ (k + n) = x ^ k * x ^ n
    protected npow_zero : ∀ (x : M), x ^ 0 = 1
    protected npow_one : ∀ (x : M), x ^ 1 = x
Arguments: {M : Type u_2} [MulOneClass M] [Pow M ℕ] [self : NatPowAssoc M] (x : M)
Goal: x ^ 1 = x
-- NatPowAssoc.npow_zero
class NatPowAssoc (M : Type*) [MulOneClass M] [Pow M ℕ] : Prop where
    protected npow_add : ∀ (k n : ℕ) (x : M), x ^ (k + n) = x ^ k * x ^ n
    protected npow_zero : ∀ (x : M), x ^ 0 = 1
    protected npow_one : ∀ (x : M), x ^ 1 = x
Arguments: {M : Type u_2} [MulOneClass M] [Pow M ℕ] [self : NatPowAssoc M] (x : M)
Goal: x ^ 0 = 1
-- NatPowAssoc.npow_add
class NatPowAssoc (M : Type*) [MulOneClass M] [Pow M ℕ] : Prop where
    protected npow_add : ∀ (k n : ℕ) (x : M), x ^ (k + n) = x ^ k * x ^ n
    protected npow_zero : ∀ (x : M), x ^ 0 = 1
    protected npow_one : ∀ (x : M), x ^ 1 = x
Arguments: {M : Type u_2} [MulOneClass M] [Pow M ℕ] [self : NatPowAssoc M] (k n : ℕ) (x : M)
Goal: x ^ (k + n) = x ^ k * x ^ n
-- npow_add
theorem npow_add (k n : ℕ) (x : M) : x ^ (k + n) = x ^ k * x ^ n  
Arguments: {M : Type u_1} [MulOneClass M] [Pow M ℕ] [NatPowAssoc M] (k n : ℕ) (x : M)
Goal: x ^ (k + n) = x ^ k * x ^ n
-- npow_zero
@[simp]
theorem npow_zero (x : M) : x ^ 0 = 1 
Arguments: {M : Type u_1} [MulOneClass M] [Pow M ℕ] [NatPowAssoc M] (x : M)
Goal: x ^ 0 = 1
-- npow_one
@[simp]
theorem npow_one (x : M) : x ^ 1 = x 
Arguments: {M : Type u_1} [MulOneClass M] [Pow M ℕ] [NatPowAssoc M] (x : M)
Goal: x ^ 1 = x
-- npow_mul_assoc
theorem npow_mul_assoc (k m n : ℕ) (x : M) :
    (x ^ k * x ^ m) * x ^ n = x ^ k * (x ^ m * x ^ n) 
Arguments: {M : Type u_1} [MulOneClass M] [Pow M ℕ] [NatPowAssoc M] (k m n : ℕ) (x : M)
Goal: x ^ k * x ^ m * x ^ n = x ^ k * (x ^ m * x ^ n)
-- npow_mul_comm
theorem npow_mul_comm (m n : ℕ) (x : M) :
    x ^ m * x ^ n = x ^ n * x ^ m 
Arguments: {M : Type u_1} [MulOneClass M] [Pow M ℕ] [NatPowAssoc M] (m n : ℕ) (x : M)
Goal: x ^ m * x ^ n = x ^ n * x ^ m
-- npow_mul
theorem npow_mul (x : M) (m n : ℕ) : x ^ (m * n) = (x ^ m) ^ n 
Arguments: {M : Type u_1} [MulOneClass M] [Pow M ℕ] [NatPowAssoc M] (x : M) (m n : ℕ)
Goal: x ^ (m * n) = (x ^ m) ^ n
-- npow_mul'
theorem npow_mul' (x : M) (m n : ℕ) : x ^ (m * n) = (x ^ n) ^ m 
Arguments: {M : Type u_1} [MulOneClass M] [Pow M ℕ] [NatPowAssoc M] (x : M) (m n : ℕ)
Goal: x ^ (m * n) = (x ^ n) ^ m
-- neg_npow_assoc
theorem neg_npow_assoc {R : Type*} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (a b : R) (k : ℕ) :
    (-1)^k * a * b = (-1)^k * (a * b) 
Arguments: {R : Type u_2} [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (a b : R) (k : ℕ)
Goal: (-1) ^ k * a * b = (-1) ^ k * (a * b)
-- Nat.cast_npow
@[simp, norm_cast]
theorem Nat.cast_npow (R : Type*) [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] (n m : ℕ) :
    (↑(n ^ m) : R) = (↑n : R) ^ m 
Arguments: (R : Type u_2) [NonAssocSemiring R] [Pow R ℕ] [NatPowAssoc R] (n m : ℕ)
Goal: ↑(n ^ m) = ↑n ^ m
-- Int.cast_npow
@[simp, norm_cast]
theorem Int.cast_npow (R : Type*) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R]
    (n : ℤ) : ∀(m : ℕ), @Int.cast R NonAssocRing.toIntCast (n ^ m) = (n : R) ^ m
  
Arguments: (R : Type u_2) [NonAssocRing R] [Pow R ℕ] [NatPowAssoc R] (n : ℤ) (m : ℕ)
Goal: ↑(n ^ m) = ↑n ^ m
-- IsAddCentral.mid_assoc
structure IsAddCentral [Add M] (z : M) : Prop where
    comm (a : M) : z + a = a + z
    left_assoc (b c : M) : z + (b + c) = (z + b) + c
    mid_assoc (a c : M) : (a + z) + c = a + (z + c)
    right_assoc (a b : M) : (a + b) + z = a + (b + z)
Arguments: {M : Type u_1} [Add M] {z : M} (self : IsAddCentral z) (a c : M)
Goal: a + z + c = a + (z + c)
-- IsAddCentral.comm
structure IsAddCentral [Add M] (z : M) : Prop where
    comm (a : M) : z + a = a + z
    left_assoc (b c : M) : z + (b + c) = (z + b) + c
    mid_assoc (a c : M) : (a + z) + c = a + (z + c)
    right_assoc (a b : M) : (a + b) + z = a + (b + z)
Arguments: {M : Type u_1} [Add M] {z : M} (self : IsAddCentral z) (a : M)
Goal: z + a = a + z
-- IsAddCentral.right_assoc
structure IsAddCentral [Add M] (z : M) : Prop where
    comm (a : M) : z + a = a + z
    left_assoc (b c : M) : z + (b + c) = (z + b) + c
    mid_assoc (a c : M) : (a + z) + c = a + (z + c)
    right_assoc (a b : M) : (a + b) + z = a + (b + z)
Arguments: {M : Type u_1} [Add M] {z : M} (self : IsAddCentral z) (a b : M)
Goal: a + b + z = a + (b + z)
-- IsAddCentral.left_assoc
structure IsAddCentral [Add M] (z : M) : Prop where
    comm (a : M) : z + a = a + z
    left_assoc (b c : M) : z + (b + c) = (z + b) + c
    mid_assoc (a c : M) : (a + z) + c = a + (z + c)
    right_assoc (a b : M) : (a + b) + z = a + (b + z)
Arguments: {M : Type u_1} [Add M] {z : M} (self : IsAddCentral z) (b c : M)
Goal: z + (b + c) = z + b + c
-- IsMulCentral.mid_assoc
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
    comm (a : M) : z * a = a * z
    left_assoc (b c : M) : z * (b * c) = (z * b) * c
    mid_assoc (a c : M) : (a * z) * c = a * (z * c)
    right_assoc (a b : M) : (a * b) * z = a * (b * z)
Arguments: {M : Type u_1} [Mul M] {z : M} (self : IsMulCentral z) (a c : M)
Goal: a * z * c = a * (z * c)
-- IsMulCentral.left_assoc
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
    comm (a : M) : z * a = a * z
    left_assoc (b c : M) : z * (b * c) = (z * b) * c
    mid_assoc (a c : M) : (a * z) * c = a * (z * c)
    right_assoc (a b : M) : (a * b) * z = a * (b * z)
Arguments: {M : Type u_1} [Mul M] {z : M} (self : IsMulCentral z) (b c : M)
Goal: z * (b * c) = z * b * c
-- IsMulCentral.right_assoc
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
    comm (a : M) : z * a = a * z
    left_assoc (b c : M) : z * (b * c) = (z * b) * c
    mid_assoc (a c : M) : (a * z) * c = a * (z * c)
    right_assoc (a b : M) : (a * b) * z = a * (b * z)
Arguments: {M : Type u_1} [Mul M] {z : M} (self : IsMulCentral z) (a b : M)
Goal: a * b * z = a * (b * z)
-- IsMulCentral.comm
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
    comm (a : M) : z * a = a * z
    left_assoc (b c : M) : z * (b * c) = (z * b) * c
    mid_assoc (a c : M) : (a * z) * c = a * (z * c)
    right_assoc (a b : M) : (a * b) * z = a * (b * z)
Arguments: {M : Type u_1} [Mul M] {z : M} (self : IsMulCentral z) (a : M)
Goal: z * a = a * z
-- IsMulCentral.left_comm
@[to_additive]
protected theorem left_comm (h : IsMulCentral a) (b c) : a * (b * c) = b * (a * c) 
Arguments: {M : Type u_1} {a : M} [Mul M] (h : IsMulCentral a) (b c : M)
Goal: a * (b * c) = b * (a * c)
-- IsAddCentral.left_comm
@[to_additive]
protected theorem left_comm (h : IsMulCentral a) (b c) : a * (b * c) = b * (a * c) 
Arguments: {M : Type u_1} {a : M} [Add M] (h : IsAddCentral a) (b c : M)
Goal: a + (b + c) = b + (a + c)
-- IsAddCentral.right_comm
@[to_additive]
protected theorem right_comm (h : IsMulCentral c) (a b) : a * b * c = a * c * b 
Arguments: {M : Type u_1} {c : M} [Add M] (h : IsAddCentral c) (a b : M)
Goal: a + b + c = a + c + b
-- IsMulCentral.right_comm
@[to_additive]
protected theorem right_comm (h : IsMulCentral c) (a b) : a * b * c = a * c * b 
Arguments: {M : Type u_1} {c : M} [Mul M] (h : IsMulCentral c) (a b : M)
Goal: a * b * c = a * c * b
-- Set.mem_addCenter_iff
@[to_additive mem_addCenter_iff]
theorem mem_center_iff {z : M} : z ∈ center M ↔ IsMulCentral z 
Arguments: {M : Type u_1} [Add M] {z : M}
Goal: z ∈ Set.addCenter M ↔ IsAddCentral z
-- Set.mem_center_iff
@[to_additive mem_addCenter_iff]
theorem mem_center_iff {z : M} : z ∈ center M ↔ IsMulCentral z 
Arguments: {M : Type u_1} [Mul M] {z : M}
Goal: z ∈ Set.center M ↔ IsMulCentral z
-- Set.mem_addCentralizer
@[to_additive mem_addCentralizer]
lemma mem_centralizer_iff {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m 
Arguments: {M : Type u_1} {S : Set M} [Add M] {c : M}
Goal: c ∈ S.addCentralizer ↔ ∀ m ∈ S, m + c = c + m
-- Set.mem_centralizer_iff
@[to_additive mem_addCentralizer]
lemma mem_centralizer_iff {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m 
Arguments: {M : Type u_1} {S : Set M} [Mul M] {c : M}
Goal: c ∈ S.centralizer ↔ ∀ m ∈ S, m * c = c * m
-- Set.mul_mem_center
@[to_additive (attr := simp) add_mem_addCenter]
theorem mul_mem_center {z₁ z₂ : M} (hz₁ : z₁ ∈ Set.center M) (hz₂ : z₂ ∈ Set.center M) :
    z₁ * z₂ ∈ Set.center M 
Arguments: {M : Type u_1} [Mul M] {z₁ z₂ : M} (hz₁ : z₁ ∈ Set.center M) (hz₂ : z₂ ∈ Set.center M)
Goal: z₁ * z₂ ∈ Set.center M
-- Set.add_mem_addCenter
@[to_additive (attr := simp) add_mem_addCenter]
theorem mul_mem_center {z₁ z₂ : M} (hz₁ : z₁ ∈ Set.center M) (hz₂ : z₂ ∈ Set.center M) :
    z₁ * z₂ ∈ Set.center M 
Arguments: {M : Type u_1} [Add M] {z₁ z₂ : M} (hz₁ : z₁ ∈ Set.addCenter M) (hz₂ : z₂ ∈ Set.addCenter M)
Goal: z₁ + z₂ ∈ Set.addCenter M
-- Set.center_subset_centralizer
@[to_additive addCenter_subset_addCentralizer]
lemma center_subset_centralizer (S : Set M) : Set.center M ⊆ S.centralizer 
Arguments: {M : Type u_1} [Mul M] (S : Set M)
Goal: Set.center M ⊆ S.centralizer
-- Set.addCenter_subset_addCentralizer
@[to_additive addCenter_subset_addCentralizer]
lemma center_subset_centralizer (S : Set M) : Set.center M ⊆ S.centralizer 
Arguments: {M : Type u_1} [Add M] (S : Set M)
Goal: Set.addCenter M ⊆ S.addCentralizer
-- Set.addCentralizer_subset
@[to_additive (attr := gcongr) addCentralizer_subset]
lemma centralizer_subset (h : S ⊆ T) : centralizer T ⊆ centralizer S 
Arguments: {M : Type u_1} {S T : Set M} [Add M] (h : S ⊆ T)
Goal: T.addCentralizer ⊆ S.addCentralizer
-- Set.centralizer_subset
@[to_additive (attr := gcongr) addCentralizer_subset]
lemma centralizer_subset (h : S ⊆ T) : centralizer T ⊆ centralizer S 
Arguments: {M : Type u_1} {S T : Set M} [Mul M] (h : S ⊆ T)
Goal: T.centralizer ⊆ S.centralizer
-- Set.subset_addCentralizer_addCentralizer
@[to_additive subset_addCentralizer_addCentralizer]
lemma subset_centralizer_centralizer : S ⊆ S.centralizer.centralizer 
Arguments: {M : Type u_1} {S : Set M} [Add M]
Goal: S ⊆ S.addCentralizer.addCentralizer
-- Set.subset_centralizer_centralizer
@[to_additive subset_addCentralizer_addCentralizer]
lemma subset_centralizer_centralizer : S ⊆ S.centralizer.centralizer 
Arguments: {M : Type u_1} {S : Set M} [Mul M]
Goal: S ⊆ S.centralizer.centralizer
-- Set.centralizer_centralizer_centralizer
@[to_additive (attr := simp) addCentralizer_addCentralizer_addCentralizer]
lemma centralizer_centralizer_centralizer (S : Set M) :
    S.centralizer.centralizer.centralizer = S.centralizer 
Arguments: {M : Type u_1} [Mul M] (S : Set M)
Goal: S.centralizer.centralizer.centralizer = S.centralizer
-- Set.addCentralizer_addCentralizer_addCentralizer
@[to_additive (attr := simp) addCentralizer_addCentralizer_addCentralizer]
lemma centralizer_centralizer_centralizer (S : Set M) :
    S.centralizer.centralizer.centralizer = S.centralizer 
Arguments: {M : Type u_1} [Add M] (S : Set M)
Goal: S.addCentralizer.addCentralizer.addCentralizer = S.addCentralizer
-- Semigroup.mem_center_iff
@[to_additive]
theorem _root_.Semigroup.mem_center_iff {z : M} :
    z ∈ Set.center M ↔ ∀ g, g * z = z * g 
Arguments: {M : Type u_1} [Semigroup M] {z : M}
Goal: z ∈ Set.center M ↔ ∀ (g : M), g * z = z * g
-- AddSemigroup.mem_center_iff
@[to_additive]
theorem _root_.Semigroup.mem_center_iff {z : M} :
    z ∈ Set.center M ↔ ∀ g, g * z = z * g 
Arguments: {M : Type u_1} [AddSemigroup M] {z : M}
Goal: z ∈ Set.addCenter M ↔ ∀ (g : M), g + z = z + g
-- Set.mul_mem_centralizer
@[to_additive (attr := simp) add_mem_addCentralizer]
lemma mul_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a * b ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [Semigroup M] {a b : M} (ha : a ∈ S.centralizer) (hb : b ∈ S.centralizer)
Goal: a * b ∈ S.centralizer
-- Set.add_mem_addCentralizer
@[to_additive (attr := simp) add_mem_addCentralizer]
lemma mul_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a * b ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [AddSemigroup M] {a b : M} (ha : a ∈ S.addCentralizer) (hb : b ∈ S.addCentralizer)
Goal: a + b ∈ S.addCentralizer
-- Set.centralizer_eq_top_iff_subset
@[to_additive (attr := simp) addCentralizer_eq_top_iff_subset]
theorem centralizer_eq_top_iff_subset : centralizer S = Set.univ ↔ S ⊆ center M 
Arguments: {M : Type u_1} {S : Set M} [Semigroup M]
Goal: S.centralizer = Set.univ ↔ S ⊆ Set.center M
-- Set.addCentralizer_eq_top_iff_subset
@[to_additive (attr := simp) addCentralizer_eq_top_iff_subset]
theorem centralizer_eq_top_iff_subset : centralizer S = Set.univ ↔ S ⊆ center M 
Arguments: {M : Type u_1} {S : Set M} [AddSemigroup M]
Goal: S.addCentralizer = Set.univ ↔ S ⊆ Set.addCenter M
-- Set.centralizer_univ
@[to_additive (attr := simp) addCentralizer_univ]
lemma centralizer_univ : centralizer univ = center M 
Arguments: (M : Type u_1) [Semigroup M]
Goal: Set.univ.centralizer = Set.center M
-- Set.addCentralizer_univ
@[to_additive (attr := simp) addCentralizer_univ]
lemma centralizer_univ : centralizer univ = center M 
Arguments: (M : Type u_1) [AddSemigroup M]
Goal: Set.univ.addCentralizer = Set.addCenter M
-- Set.center_eq_univ
@[to_additive (attr := simp) addCenter_eq_univ]
theorem center_eq_univ : center M = univ 
Arguments: (M : Type u_1) [CommSemigroup M]
Goal: Set.center M = Set.univ
-- Set.addCenter_eq_univ
@[to_additive (attr := simp) addCenter_eq_univ]
theorem center_eq_univ : center M = univ 
Arguments: (M : Type u_1) [AddCommSemigroup M]
Goal: Set.addCenter M = Set.univ
-- Set.addCentralizer_eq_univ
@[to_additive (attr := simp) addCentralizer_eq_univ]
lemma centralizer_eq_univ : centralizer S = univ 
Arguments: (M : Type u_1) {S : Set M} [AddCommSemigroup M]
Goal: S.addCentralizer = Set.univ
-- Set.centralizer_eq_univ
@[to_additive (attr := simp) addCentralizer_eq_univ]
lemma centralizer_eq_univ : centralizer S = univ 
Arguments: (M : Type u_1) {S : Set M} [CommSemigroup M]
Goal: S.centralizer = Set.univ
-- Set.zero_mem_addCenter
@[to_additive (attr := simp) zero_mem_addCenter]
theorem one_mem_center : (1 : M) ∈ Set.center M 
Arguments: {M : Type u_1} [AddZeroClass M]
Goal: 0 ∈ Set.addCenter M
-- Set.one_mem_center
@[to_additive (attr := simp) zero_mem_addCenter]
theorem one_mem_center : (1 : M) ∈ Set.center M 
Arguments: {M : Type u_1} [MulOneClass M]
Goal: 1 ∈ Set.center M
-- Set.one_mem_centralizer
@[to_additive (attr := simp) zero_mem_addCentralizer]
lemma one_mem_centralizer : (1 : M) ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [MulOneClass M]
Goal: 1 ∈ S.centralizer
-- Set.zero_mem_addCentralizer
@[to_additive (attr := simp) zero_mem_addCentralizer]
lemma one_mem_centralizer : (1 : M) ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [AddZeroClass M]
Goal: 0 ∈ S.addCentralizer
-- Set.subset_addCenter_add_units
@[to_additive subset_addCenter_add_units]
theorem subset_center_units : ((↑) : Mˣ → M) ⁻¹' center M ⊆ Set.center Mˣ 
Arguments: {M : Type u_1} [AddMonoid M]
Goal: AddUnits.val ⁻¹' Set.addCenter M ⊆ Set.addCenter (AddUnits M)
-- Set.subset_center_units
@[to_additive subset_addCenter_add_units]
theorem subset_center_units : ((↑) : Mˣ → M) ⁻¹' center M ⊆ Set.center Mˣ 
Arguments: {M : Type u_1} [Monoid M]
Goal: Units.val ⁻¹' Set.center M ⊆ Set.center Mˣ
-- Set.addUnits_neg_mem_center
@[to_additive (attr := simp)]
theorem units_inv_mem_center {a : Mˣ} (ha : ↑a ∈ Set.center M) : ↑a⁻¹ ∈ Set.center M 
Arguments: {M : Type u_1} [AddMonoid M] {a : AddUnits M} (ha : ↑a ∈ Set.addCenter M)
Goal: ↑(-a) ∈ Set.addCenter M
-- Set.units_inv_mem_center
@[to_additive (attr := simp)]
theorem units_inv_mem_center {a : Mˣ} (ha : ↑a ∈ Set.center M) : ↑a⁻¹ ∈ Set.center M 
Arguments: {M : Type u_1} [Monoid M] {a : Mˣ} (ha : ↑a ∈ Set.center M)
Goal: ↑a⁻¹ ∈ Set.center M
-- Set.invOf_mem_center
@[simp]
theorem invOf_mem_center {a : M} [Invertible a] (ha : a ∈ Set.center M) : ⅟a ∈ Set.center M 
Arguments: {M : Type u_1} [Monoid M] {a : M} [Invertible a] (ha : a ∈ Set.center M)
Goal: ⅟a ∈ Set.center M
-- Set.neg_mem_addCenter
@[to_additive (attr := simp) neg_mem_addCenter]
theorem inv_mem_center (ha : a ∈ Set.center M) : a⁻¹ ∈ Set.center M 
Arguments: {M : Type u_1} [SubtractionMonoid M] {a : M} (ha : a ∈ Set.addCenter M)
Goal: -a ∈ Set.addCenter M
-- Set.inv_mem_center
@[to_additive (attr := simp) neg_mem_addCenter]
theorem inv_mem_center (ha : a ∈ Set.center M) : a⁻¹ ∈ Set.center M 
Arguments: {M : Type u_1} [DivisionMonoid M] {a : M} (ha : a ∈ Set.center M)
Goal: a⁻¹ ∈ Set.center M
-- Set.div_mem_center
@[to_additive (attr := simp) sub_mem_addCenter]
theorem div_mem_center (ha : a ∈ Set.center M) (hb : b ∈ Set.center M) : a / b ∈ Set.center M 
Arguments: {M : Type u_1} [DivisionMonoid M] {a b : M} (ha : a ∈ Set.center M) (hb : b ∈ Set.center M)
Goal: a / b ∈ Set.center M
-- Set.sub_mem_addCenter
@[to_additive (attr := simp) sub_mem_addCenter]
theorem div_mem_center (ha : a ∈ Set.center M) (hb : b ∈ Set.center M) : a / b ∈ Set.center M 
Arguments: {M : Type u_1} [SubtractionMonoid M] {a b : M} (ha : a ∈ Set.addCenter M) (hb : b ∈ Set.addCenter M)
Goal: a - b ∈ Set.addCenter M
-- Set.neg_mem_addCentralizer
@[to_additive (attr := simp) neg_mem_addCentralizer]
lemma inv_mem_centralizer (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [AddGroup M] {a : M} (ha : a ∈ S.addCentralizer)
Goal: -a ∈ S.addCentralizer
-- Set.inv_mem_centralizer
@[to_additive (attr := simp) neg_mem_addCentralizer]
lemma inv_mem_centralizer (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [Group M] {a : M} (ha : a ∈ S.centralizer)
Goal: a⁻¹ ∈ S.centralizer
-- Set.div_mem_centralizer
@[to_additive (attr := simp) sub_mem_addCentralizer]
lemma div_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a / b ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [Group M] {a b : M} (ha : a ∈ S.centralizer) (hb : b ∈ S.centralizer)
Goal: a / b ∈ S.centralizer
-- Set.sub_mem_addCentralizer
@[to_additive (attr := simp) sub_mem_addCentralizer]
lemma div_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a / b ∈ centralizer S 
Arguments: {M : Type u_1} {S : Set M} [AddGroup M] {a b : M} (ha : a ∈ S.addCentralizer) (hb : b ∈ S.addCentralizer)
Goal: a - b ∈ S.addCentralizer
-- commutatorElement_def
theorem commutatorElement_def {G : Type*} [Group G] (g₁ g₂ : G) :
    ⁅g₁, g₂⁆ = g₁ * g₂ * g₁⁻¹ * g₂⁻¹ 
Arguments: {G : Type u_1} [Group G] (g₁ g₂ : G)
Goal: ⁅g₁, g₂⁆ = g₁ * g₂ * g₁⁻¹ * g₂⁻¹
-- Submonoid.toAddSubmonoid_symm_apply_coe
@[simps]
def Submonoid.toAddSubmonoid : Submonoid M ≃o AddSubmonoid (Additive M) 
Arguments: {M : Type u_1} [MulOneClass M] (S : AddSubmonoid (Additive M))
Goal: ↑((RelIso.symm Submonoid.toAddSubmonoid) S) = ⇑Additive.ofMul ⁻¹' ↑S
-- Submonoid.toAddSubmonoid_apply_coe
@[simps]
def Submonoid.toAddSubmonoid : Submonoid M ≃o AddSubmonoid (Additive M) 
Arguments: {M : Type u_1} [MulOneClass M] (S : Submonoid M)
Goal: ↑(Submonoid.toAddSubmonoid S) = ⇑Additive.toMul ⁻¹' ↑S
-- Submonoid.toAddSubmonoid_closure
theorem Submonoid.toAddSubmonoid_closure (S : Set M) :
    Submonoid.toAddSubmonoid (Submonoid.closure S)
      = AddSubmonoid.closure (Additive.toMul ⁻¹' S) 
Arguments: {M : Type u_1} [MulOneClass M] (S : Set M)
Goal: Submonoid.toAddSubmonoid (Submonoid.closure S) = AddSubmonoid.closure (⇑Additive.toMul ⁻¹' S)
-- AddSubmonoid.toSubmonoid'_closure
theorem AddSubmonoid.toSubmonoid'_closure (S : Set (Additive M)) :
    AddSubmonoid.toSubmonoid' (AddSubmonoid.closure S)
      = Submonoid.closure (Multiplicative.ofAdd ⁻¹' S) 
Arguments: {M : Type u_1} [MulOneClass M] (S : Set (Additive M))
Goal: AddSubmonoid.toSubmonoid' (AddSubmonoid.closure S) = Submonoid.closure (⇑Multiplicative.ofAdd ⁻¹' S)
-- AddSubmonoid.toSubmonoid_apply_coe
@[simps]
def AddSubmonoid.toSubmonoid : AddSubmonoid A ≃o Submonoid (Multiplicative A) 
Arguments: {A : Type u_4} [AddZeroClass A] (S : AddSubmonoid A)
Goal: ↑(AddSubmonoid.toSubmonoid S) = ⇑Multiplicative.toAdd ⁻¹' ↑S
-- AddSubmonoid.toSubmonoid_symm_apply_coe
@[simps]
def AddSubmonoid.toSubmonoid : AddSubmonoid A ≃o Submonoid (Multiplicative A) 
Arguments: {A : Type u_4} [AddZeroClass A] (S : Submonoid (Multiplicative A))
Goal: ↑((RelIso.symm AddSubmonoid.toSubmonoid) S) = ⇑Multiplicative.ofAdd ⁻¹' ↑S
-- AddSubmonoid.toSubmonoid_closure
theorem AddSubmonoid.toSubmonoid_closure (S : Set A) :
    (AddSubmonoid.toSubmonoid) (AddSubmonoid.closure S)
      = Submonoid.closure (Multiplicative.toAdd ⁻¹' S) 
Arguments: {A : Type u_4} [AddZeroClass A] (S : Set A)
Goal: AddSubmonoid.toSubmonoid (AddSubmonoid.closure S) = Submonoid.closure (⇑Multiplicative.toAdd ⁻¹' S)
-- Submonoid.toAddSubmonoid'_closure
theorem Submonoid.toAddSubmonoid'_closure (S : Set (Multiplicative A)) :
    Submonoid.toAddSubmonoid' (Submonoid.closure S)
      = AddSubmonoid.closure (Additive.ofMul ⁻¹' S) 
Arguments: {A : Type u_4} [AddZeroClass A] (S : Set (Multiplicative A))
Goal: Submonoid.toAddSubmonoid' (Submonoid.closure S) = AddSubmonoid.closure (⇑Additive.ofMul ⁻¹' S)
-- Submonoid.coe_comap
@[to_additive (attr := simp)]
theorem coe_comap (S : Submonoid N) (f : F) : (S.comap f : Set M) = f ⁻¹' S 
Arguments: {M : Type u_1} {N : Type u_2} [MulOneClass M] [MulOneClass N] {F : Type u_4} [FunLike F M N] [mc : MonoidHomClass F M N] (S : Submonoid N) (f : F)
Goal: ↑(Submonoid.comap f S) = ⇑f ⁻¹' ↑S
-- AddSubmonoid.coe_comap
@[to_additive (attr := simp)]
theorem coe_comap (S : Submonoid N) (f : F) : (S.comap f : Set M) = f ⁻¹' S 
Arguments: {M : Type u_1} {N : Type u_2} [AddZeroClass M] [AddZeroClass N] {F : Type u_4} [FunLike F M N] [mc : AddMonoidHomClass F M N] (S : AddSubmonoid N) (f : F)
Goal: ↑(AddSubmonoid.comap f S) = ⇑f ⁻¹' ↑S