File: Mathlib/Algebra/Group/Center.lean

full_name: IsAddCentral.mid_assoc
code: /-- Conditions for an element to be additively central -/
structure IsAddCentral [Add M] (z : M) : Prop where
  /-- addition commutes -/
  comm (a : M) : z + a = a + z
  /-- associative property for left addition -/
  left_assoc (b c : M) : z + (b + c) = (z + b) + c
  /-- middle associative addition property -/
  mid_assoc (a c : M) : (a + z) + c = a + (z + c)
  /-- associative property for right addition -/
  right_assoc (a b : M) : (a + b) + z = a + (b + z)
goal: a + z + c = a + (z + c)

full_name: IsAddCentral.comm
code: /-- Conditions for an element to be additively central -/
structure IsAddCentral [Add M] (z : M) : Prop where
  /-- addition commutes -/
  comm (a : M) : z + a = a + z
  /-- associative property for left addition -/
  left_assoc (b c : M) : z + (b + c) = (z + b) + c
  /-- middle associative addition property -/
  mid_assoc (a c : M) : (a + z) + c = a + (z + c)
  /-- associative property for right addition -/
  right_assoc (a b : M) : (a + b) + z = a + (b + z)
goal: z + a = a + z

full_name: IsAddCentral
code: /-- Conditions for an element to be additively central -/
structure IsAddCentral [Add M] (z : M) : Prop where
  /-- addition commutes -/
  comm (a : M) : z + a = a + z
  /-- associative property for left addition -/
  left_assoc (b c : M) : z + (b + c) = (z + b) + c
  /-- middle associative addition property -/
  mid_assoc (a c : M) : (a + z) + c = a + (z + c)
  /-- associative property for right addition -/
  right_assoc (a b : M) : (a + b) + z = a + (b + z)
goal: Prop

full_name: IsAddCentral.right_assoc
code: /-- Conditions for an element to be additively central -/
structure IsAddCentral [Add M] (z : M) : Prop where
  /-- addition commutes -/
  comm (a : M) : z + a = a + z
  /-- associative property for left addition -/
  left_assoc (b c : M) : z + (b + c) = (z + b) + c
  /-- middle associative addition property -/
  mid_assoc (a c : M) : (a + z) + c = a + (z + c)
  /-- associative property for right addition -/
  right_assoc (a b : M) : (a + b) + z = a + (b + z)
goal: a + b + z = a + (b + z)

full_name: IsAddCentral.left_assoc
code: /-- Conditions for an element to be additively central -/
structure IsAddCentral [Add M] (z : M) : Prop where
  /-- addition commutes -/
  comm (a : M) : z + a = a + z
  /-- associative property for left addition -/
  left_assoc (b c : M) : z + (b + c) = (z + b) + c
  /-- middle associative addition property -/
  mid_assoc (a c : M) : (a + z) + c = a + (z + c)
  /-- associative property for right addition -/
  right_assoc (a b : M) : (a + b) + z = a + (b + z)
goal: z + (b + c) = z + b + c

full_name: IsMulCentral.mid_assoc
code: /-- Conditions for an element to be multiplicatively central -/
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
  /-- multiplication commutes -/
  comm (a : M) : z * a = a * z
  /-- associative property for left multiplication -/
  left_assoc (b c : M) : z * (b * c) = (z * b) * c
  /-- middle associative multiplication property -/
  mid_assoc (a c : M) : (a * z) * c = a * (z * c)
  /-- associative property for right multiplication -/
  right_assoc (a b : M) : (a * b) * z = a * (b * z)
goal: a * z * c = a * (z * c)

full_name: IsMulCentral.left_assoc
code: /-- Conditions for an element to be multiplicatively central -/
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
  /-- multiplication commutes -/
  comm (a : M) : z * a = a * z
  /-- associative property for left multiplication -/
  left_assoc (b c : M) : z * (b * c) = (z * b) * c
  /-- middle associative multiplication property -/
  mid_assoc (a c : M) : (a * z) * c = a * (z * c)
  /-- associative property for right multiplication -/
  right_assoc (a b : M) : (a * b) * z = a * (b * z)
goal: z * (b * c) = z * b * c

full_name: IsMulCentral.right_assoc
code: /-- Conditions for an element to be multiplicatively central -/
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
  /-- multiplication commutes -/
  comm (a : M) : z * a = a * z
  /-- associative property for left multiplication -/
  left_assoc (b c : M) : z * (b * c) = (z * b) * c
  /-- middle associative multiplication property -/
  mid_assoc (a c : M) : (a * z) * c = a * (z * c)
  /-- associative property for right multiplication -/
  right_assoc (a b : M) : (a * b) * z = a * (b * z)
goal: a * b * z = a * (b * z)

full_name: IsMulCentral.comm
code: /-- Conditions for an element to be multiplicatively central -/
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
  /-- multiplication commutes -/
  comm (a : M) : z * a = a * z
  /-- associative property for left multiplication -/
  left_assoc (b c : M) : z * (b * c) = (z * b) * c
  /-- middle associative multiplication property -/
  mid_assoc (a c : M) : (a * z) * c = a * (z * c)
  /-- associative property for right multiplication -/
  right_assoc (a b : M) : (a * b) * z = a * (b * z)
goal: z * a = a * z

full_name: IsMulCentral
code: /-- Conditions for an element to be multiplicatively central -/
@[to_additive]
structure IsMulCentral [Mul M] (z : M) : Prop where
  /-- multiplication commutes -/
  comm (a : M) : z * a = a * z
  /-- associative property for left multiplication -/
  left_assoc (b c : M) : z * (b * c) = (z * b) * c
  /-- middle associative multiplication property -/
  mid_assoc (a c : M) : (a * z) * c = a * (z * c)
  /-- associative property for right multiplication -/
  right_assoc (a b : M) : (a * b) * z = a * (b * z)
goal: Prop

full_name: IsMulCentral.left_comm
code: @[to_additive]
protected theorem left_comm (h : IsMulCentral a) (b c) : a * (b * c) = b * (a * c) 
goal: a * (b * c) = b * (a * c)

full_name: IsAddCentral.left_comm
code: @[to_additive]
protected theorem left_comm (h : IsMulCentral a) (b c) : a * (b * c) = b * (a * c) 
goal: a + (b + c) = b + (a + c)

full_name: IsAddCentral.right_comm
code: @[to_additive]
protected theorem right_comm (h : IsMulCentral c) (a b) : a * b * c = a * c * b 
goal: a + b + c = a + c + b

full_name: IsMulCentral.right_comm
code: @[to_additive]
protected theorem right_comm (h : IsMulCentral c) (a b) : a * b * c = a * c * b 
goal: a * b * c = a * c * b

full_name: Set.addCenter
code: /-- The center of a magma. -/
@[to_additive addCenter " The center of an additive magma. "]
def center : Set M 
goal: Set M

full_name: Set.center
code: /-- The center of a magma. -/
@[to_additive addCenter " The center of an additive magma. "]
def center : Set M 
goal: Set M

full_name: Set.centralizer
code: /-- The centralizer of a subset of a magma. -/
@[to_additive addCentralizer " The centralizer of a subset of an additive magma. "]
def centralizer : Set M 
goal: Set M

full_name: Set.addCentralizer
code: /-- The centralizer of a subset of a magma. -/
@[to_additive addCentralizer " The centralizer of a subset of an additive magma. "]
def centralizer : Set M 
goal: Set M

full_name: Set.mem_addCenter_iff
code: @[to_additive mem_addCenter_iff]
theorem mem_center_iff {z : M} : z ∈ center M ↔ IsMulCentral z 
goal: z ∈ Set.addCenter M ↔ IsAddCentral z

full_name: Set.mem_center_iff
code: @[to_additive mem_addCenter_iff]
theorem mem_center_iff {z : M} : z ∈ center M ↔ IsMulCentral z 
goal: z ∈ Set.center M ↔ IsMulCentral z

full_name: Set.mem_addCentralizer
code: @[to_additive mem_addCentralizer]
lemma mem_centralizer_iff {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m 
goal: c ∈ S.addCentralizer ↔ ∀ m ∈ S, m + c = c + m

full_name: Set.mem_centralizer_iff
code: @[to_additive mem_addCentralizer]
lemma mem_centralizer_iff {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m 
goal: c ∈ S.centralizer ↔ ∀ m ∈ S, m * c = c * m

full_name: Set.mul_mem_center
code: @[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 
goal: z₁ * z₂ ∈ Set.center M

full_name: Set.add_mem_addCenter
code: @[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 
goal: z₁ + z₂ ∈ Set.addCenter M

full_name: Set.center_subset_centralizer
code: @[to_additive addCenter_subset_addCentralizer]
lemma center_subset_centralizer (S : Set M) : Set.center M ⊆ S.centralizer 
goal: Set.center M ⊆ S.centralizer

full_name: Set.addCenter_subset_addCentralizer
code: @[to_additive addCenter_subset_addCentralizer]
lemma center_subset_centralizer (S : Set M) : Set.center M ⊆ S.centralizer 
goal: Set.addCenter M ⊆ S.addCentralizer

full_name: Set.addCentralizer_subset
code: @[to_additive (attr := gcongr) addCentralizer_subset]
lemma centralizer_subset (h : S ⊆ T) : centralizer T ⊆ centralizer S 
goal: T.addCentralizer ⊆ S.addCentralizer

full_name: Set.centralizer_subset
code: @[to_additive (attr := gcongr) addCentralizer_subset]
lemma centralizer_subset (h : S ⊆ T) : centralizer T ⊆ centralizer S 
goal: T.centralizer ⊆ S.centralizer

full_name: Set.subset_addCentralizer_addCentralizer
code: @[to_additive subset_addCentralizer_addCentralizer]
lemma subset_centralizer_centralizer : S ⊆ S.centralizer.centralizer 
goal: S ⊆ S.addCentralizer.addCentralizer

full_name: Set.subset_centralizer_centralizer
code: @[to_additive subset_addCentralizer_addCentralizer]
lemma subset_centralizer_centralizer : S ⊆ S.centralizer.centralizer 
goal: S ⊆ S.centralizer.centralizer

full_name: Set.centralizer_centralizer_centralizer
code: @[to_additive (attr := simp) addCentralizer_addCentralizer_addCentralizer]
lemma centralizer_centralizer_centralizer (S : Set M) :
    S.centralizer.centralizer.centralizer = S.centralizer 
goal: S.centralizer.centralizer.centralizer = S.centralizer

full_name: Set.addCentralizer_addCentralizer_addCentralizer
code: @[to_additive (attr := simp) addCentralizer_addCentralizer_addCentralizer]
lemma centralizer_centralizer_centralizer (S : Set M) :
    S.centralizer.centralizer.centralizer = S.centralizer 
goal: S.addCentralizer.addCentralizer.addCentralizer = S.addCentralizer

full_name: Set.decidableMemAddCentralizer
code: @[to_additive decidableMemAddCentralizer]
instance decidableMemCentralizer [∀ a : M, Decidable <| ∀ b ∈ S, b * a = a * b] :
    DecidablePred (· ∈ centralizer S) 
goal: DecidablePred fun x => x ∈ S.addCentralizer

full_name: Set.decidableMemCentralizer
code: @[to_additive decidableMemAddCentralizer]
instance decidableMemCentralizer [∀ a : M, Decidable <| ∀ b ∈ S, b * a = a * b] :
    DecidablePred (· ∈ centralizer S) 
goal: DecidablePred fun x => x ∈ S.centralizer

full_name: Semigroup.mem_center_iff
code: @[to_additive]
theorem _root_.Semigroup.mem_center_iff {z : M} :
    z ∈ Set.center M ↔ ∀ g, g * z = z * g 
goal: z ∈ Set.center M ↔ ∀ (g : M), g * z = z * g

full_name: AddSemigroup.mem_center_iff
code: @[to_additive]
theorem _root_.Semigroup.mem_center_iff {z : M} :
    z ∈ Set.center M ↔ ∀ g, g * z = z * g 
goal: z ∈ Set.addCenter M ↔ ∀ (g : M), g + z = z + g

full_name: Set.mul_mem_centralizer
code: @[to_additive (attr := simp) add_mem_addCentralizer]
lemma mul_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a * b ∈ centralizer S 
goal: a * b ∈ S.centralizer

full_name: Set.add_mem_addCentralizer
code: @[to_additive (attr := simp) add_mem_addCentralizer]
lemma mul_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a * b ∈ centralizer S 
goal: a + b ∈ S.addCentralizer

full_name: Set.centralizer_eq_top_iff_subset
code: @[to_additive (attr := simp) addCentralizer_eq_top_iff_subset]
theorem centralizer_eq_top_iff_subset : centralizer S = Set.univ ↔ S ⊆ center M 
goal: S.centralizer = Set.univ ↔ S ⊆ Set.center M

full_name: Set.addCentralizer_eq_top_iff_subset
code: @[to_additive (attr := simp) addCentralizer_eq_top_iff_subset]
theorem centralizer_eq_top_iff_subset : centralizer S = Set.univ ↔ S ⊆ center M 
goal: S.addCentralizer = Set.univ ↔ S ⊆ Set.addCenter M

full_name: Set.centralizer_univ
code: @[to_additive (attr := simp) addCentralizer_univ]
lemma centralizer_univ : centralizer univ = center M 
goal: Set.univ.centralizer = Set.center M

full_name: Set.addCentralizer_univ
code: @[to_additive (attr := simp) addCentralizer_univ]
lemma centralizer_univ : centralizer univ = center M 
goal: Set.univ.addCentralizer = Set.addCenter M

full_name: Set.decidableMemCenter
code: @[to_additive decidableMemAddCenter]
instance decidableMemCenter [∀ a : M, Decidable <| ∀ b : M, b * a = a * b] :
    DecidablePred (· ∈ center M) 
goal: DecidablePred fun x => x ∈ Set.center M

full_name: Set.decidableMemAddCenter
code: @[to_additive decidableMemAddCenter]
instance decidableMemCenter [∀ a : M, Decidable <| ∀ b : M, b * a = a * b] :
    DecidablePred (· ∈ center M) 
goal: DecidablePred fun x => x ∈ Set.addCenter M

full_name: Set.center_eq_univ
code: @[to_additive (attr := simp) addCenter_eq_univ]
theorem center_eq_univ : center M = univ 
goal: Set.center M = Set.univ

full_name: Set.addCenter_eq_univ
code: @[to_additive (attr := simp) addCenter_eq_univ]
theorem center_eq_univ : center M = univ 
goal: Set.addCenter M = Set.univ

full_name: Set.addCentralizer_eq_univ
code: @[to_additive (attr := simp) addCentralizer_eq_univ]
lemma centralizer_eq_univ : centralizer S = univ 
goal: S.addCentralizer = Set.univ

full_name: Set.centralizer_eq_univ
code: @[to_additive (attr := simp) addCentralizer_eq_univ]
lemma centralizer_eq_univ : centralizer S = univ 
goal: S.centralizer = Set.univ

full_name: Set.zero_mem_addCenter
code: @[to_additive (attr := simp) zero_mem_addCenter]
theorem one_mem_center : (1 : M) ∈ Set.center M 
goal: 0 ∈ Set.addCenter M

full_name: Set.one_mem_center
code: @[to_additive (attr := simp) zero_mem_addCenter]
theorem one_mem_center : (1 : M) ∈ Set.center M 
goal: 1 ∈ Set.center M

full_name: Set.one_mem_centralizer
code: @[to_additive (attr := simp) zero_mem_addCentralizer]
lemma one_mem_centralizer : (1 : M) ∈ centralizer S 
goal: 1 ∈ S.centralizer

full_name: Set.zero_mem_addCentralizer
code: @[to_additive (attr := simp) zero_mem_addCentralizer]
lemma one_mem_centralizer : (1 : M) ∈ centralizer S 
goal: 0 ∈ S.addCentralizer

full_name: Set.subset_addCenter_add_units
code: @[to_additive subset_addCenter_add_units]
theorem subset_center_units : ((↑) : Mˣ → M) ⁻¹' center M ⊆ Set.center Mˣ 
goal: AddUnits.val ⁻¹' Set.addCenter M ⊆ Set.addCenter (AddUnits M)

full_name: Set.subset_center_units
code: @[to_additive subset_addCenter_add_units]
theorem subset_center_units : ((↑) : Mˣ → M) ⁻¹' center M ⊆ Set.center Mˣ 
goal: Units.val ⁻¹' Set.center M ⊆ Set.center Mˣ

full_name: Set.addUnits_neg_mem_center
code: @[to_additive (attr := simp)]
theorem units_inv_mem_center {a : Mˣ} (ha : ↑a ∈ Set.center M) : ↑a⁻¹ ∈ Set.center M 
goal: ↑(-a) ∈ Set.addCenter M

full_name: Set.units_inv_mem_center
code: @[to_additive (attr := simp)]
theorem units_inv_mem_center {a : Mˣ} (ha : ↑a ∈ Set.center M) : ↑a⁻¹ ∈ Set.center M 
goal: ↑a⁻¹ ∈ Set.center M

full_name: Set.invOf_mem_center
code: @[simp]
theorem invOf_mem_center {a : M} [Invertible a] (ha : a ∈ Set.center M) : ⅟a ∈ Set.center M 
goal: ⅟a ∈ Set.center M

full_name: Set.neg_mem_addCenter
code: @[to_additive (attr := simp) neg_mem_addCenter]
theorem inv_mem_center (ha : a ∈ Set.center M) : a⁻¹ ∈ Set.center M 
goal: -a ∈ Set.addCenter M

full_name: Set.inv_mem_center
code: @[to_additive (attr := simp) neg_mem_addCenter]
theorem inv_mem_center (ha : a ∈ Set.center M) : a⁻¹ ∈ Set.center M 
goal: a⁻¹ ∈ Set.center M

full_name: Set.div_mem_center
code: @[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 
goal: a / b ∈ Set.center M

full_name: Set.sub_mem_addCenter
code: @[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 
goal: a - b ∈ Set.addCenter M

full_name: Set.neg_mem_addCentralizer
code: @[to_additive (attr := simp) neg_mem_addCentralizer]
lemma inv_mem_centralizer (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S 
goal: -a ∈ S.addCentralizer

full_name: Set.inv_mem_centralizer
code: @[to_additive (attr := simp) neg_mem_addCentralizer]
lemma inv_mem_centralizer (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S 
goal: a⁻¹ ∈ S.centralizer

full_name: Set.div_mem_centralizer
code: @[to_additive (attr := simp) sub_mem_addCentralizer]
lemma div_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a / b ∈ centralizer S 
goal: a / b ∈ S.centralizer

full_name: Set.sub_mem_addCentralizer
code: @[to_additive (attr := simp) sub_mem_addCentralizer]
lemma div_mem_centralizer (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
    a / b ∈ centralizer S 
goal: a - b ∈ S.addCentralizer