group_theory.subsemigroup.centralizer | Mathlib porting status

(last sync)

chore(*/centralizer): add forgotten to_additives (#19168)

I forgot these in #18861. These are already in the forward-port PR, leanprover-community/mathlib4#4896.

Diff

@@ -100,10 +100,12 @@ end
 lemma centralizer_subset [has_mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer S :=
 λ t ht s hs, ht s (h hs)
 
+@[to_additive add_center_subset_add_centralizer]
 lemma center_subset_centralizer [has_mul M] (S : set M) : set.center M ⊆ S.centralizer :=
 λ x hx m _, hx m
 
-@[simp] lemma centralizer_eq_top_iff_subset {s : set M} [has_mul M] :
+@[simp, to_additive add_centralizer_eq_top_iff_subset]
+lemma centralizer_eq_top_iff_subset {s : set M} [has_mul M] :
   centralizer s = set.univ ↔ s ⊆ center M :=
 eq_top_iff.trans $ ⟨λ h x hx g, (h trivial _ hx).symm,
                     λ h x _ m hm, (h hm x).symm⟩
@@ -144,13 +146,15 @@ iff.rfl
   decidable (a ∈ centralizer S) :=
 decidable_of_iff' _ mem_centralizer_iff
 
+@[to_additive]
 lemma center_le_centralizer (S) : center M ≤ centralizer S := S.center_subset_centralizer
 
 @[to_additive]
 lemma centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
 set.centralizer_subset h
 
-@[simp] lemma centralizer_eq_top_iff_subset {s : set M} : centralizer s = ⊤ ↔ s ⊆ center M :=
+@[simp, to_additive]
+lemma centralizer_eq_top_iff_subset {s : set M} : centralizer s = ⊤ ↔ s ⊆ center M :=
 set_like.ext'_iff.trans set.centralizer_eq_top_iff_subset
 
 variables (M)

b915e939

feat(ring_theory/subring): centralizer as a subring (#18861)

Co-authored-by: Eric Rodriguez <37984851+ericrbg@users.noreply.github.com>

Diff

@@ -100,6 +100,14 @@ end
 lemma centralizer_subset [has_mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer S :=
 λ t ht s hs, ht s (h hs)
 
+lemma center_subset_centralizer [has_mul M] (S : set M) : set.center M ⊆ S.centralizer :=
+λ x hx m _, hx m
+
+@[simp] lemma centralizer_eq_top_iff_subset {s : set M} [has_mul M] :
+  centralizer s = set.univ ↔ s ⊆ center M :=
+eq_top_iff.trans $ ⟨λ h x hx g, (h trivial _ hx).symm,
+                    λ h x _ m hm, (h hm x).symm⟩
+
 variables (M)
 
 @[simp, to_additive add_centralizer_univ]
@@ -112,6 +120,7 @@ variables {M} (S)
 lemma centralizer_eq_univ [comm_semigroup M] : centralizer S = univ :=
 subset.antisymm (subset_univ _) $ λ x hx y hy, mul_comm y x
 
+
 end set
 
 namespace subsemigroup
@@ -135,10 +144,15 @@ iff.rfl
   decidable (a ∈ centralizer S) :=
 decidable_of_iff' _ mem_centralizer_iff
 
+lemma center_le_centralizer (S) : center M ≤ centralizer S := S.center_subset_centralizer
+
 @[to_additive]
 lemma centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
 set.centralizer_subset h
 
+@[simp] lemma centralizer_eq_top_iff_subset {s : set M} : centralizer s = ⊤ ↔ s ⊆ center M :=
+set_like.ext'_iff.trans set.centralizer_eq_top_iff_subset
+
 variables (M)
 
 @[simp, to_additive]

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-23-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/65a1391a0106c9204fe45bc73a039f056558cb83

b220bd4d

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2021 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
 -/
-import GroupTheory.Subsemigroup.Center
+import Algebra.Group.Center
 import Algebra.GroupWithZero.Units.Lemmas
 
 #align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"

bump to nightly-2023-09-24-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/ce64cd319bb6b3e82f31c2d38e79080d377be451

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2021 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
 -/
-import Mathbin.GroupTheory.Subsemigroup.Center
-import Mathbin.Algebra.GroupWithZero.Units.Lemmas
+import GroupTheory.Subsemigroup.Center
+import Algebra.GroupWithZero.Units.Lemmas
 
 #align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"

bump to nightly-2023-08-17-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/32a7e535287f9c73f2e4d2aef306a39190f0b504

60285dcc

Diff

@@ -194,7 +194,7 @@ variable {M} [Semigroup M] (S)
 @[to_additive "The centralizer of a subset of an additive semigroup."]
 def centralizer : Subsemigroup M where
   carrier := S.centralizer
-  mul_mem' a b := Set.mul_mem_centralizer
+  hMul_mem' a b := Set.mul_mem_centralizer
 #align subsemigroup.centralizer Subsemigroup.centralizer
 #align add_subsemigroup.centralizer AddSubsemigroup.centralizer
 -/

bump to nightly-2023-07-20-09

mathlib commit https://github.com/leanprover-community/mathlib/commit/8ea5598db6caeddde6cb734aa179cc2408dbd345

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
-
-! This file was ported from Lean 3 source module group_theory.subsemigroup.centralizer
-! leanprover-community/mathlib commit cc67cd75b4e54191e13c2e8d722289a89e67e4fa
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.GroupTheory.Subsemigroup.Center
 import Mathbin.Algebra.GroupWithZero.Units.Lemmas
 
+#align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"
+
 /-!
 # Centralizers of magmas and semigroups

bump to nightly-2023-06-13-21

mathlib commit https://github.com/leanprover-community/mathlib/commit/9fb8964792b4237dac6200193a0d533f1b3f7423

829520ac

Diff

@@ -64,48 +64,63 @@ instance decidableMemCentralizer [Mul M] [∀ a : M, Decidable <| ∀ b ∈ S, b
 
 variable (S)
 
+#print Set.one_mem_centralizer /-
 @[simp, to_additive zero_mem_add_centralizer]
 theorem one_mem_centralizer [MulOneClass M] : (1 : M) ∈ centralizer S := by
   simp [mem_centralizer_iff]
 #align set.one_mem_centralizer Set.one_mem_centralizer
 #align set.zero_mem_add_centralizer Set.zero_mem_addCentralizer
+-/
 
+#print Set.zero_mem_centralizer /-
 @[simp]
 theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
   simp [mem_centralizer_iff]
 #align set.zero_mem_centralizer Set.zero_mem_centralizer
+-/
 
 variable {S} {a b : M}
 
+#print Set.mul_mem_centralizer /-
 @[simp, to_additive add_mem_add_centralizer]
 theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a * b ∈ centralizer S := fun g hg => by
   rw [mul_assoc, ← hb g hg, ← mul_assoc, ha g hg, mul_assoc]
 #align set.mul_mem_centralizer Set.mul_mem_centralizer
 #align set.add_mem_add_centralizer Set.add_mem_addCentralizer
+-/
 
+#print Set.inv_mem_centralizer /-
 @[simp, to_additive neg_mem_add_centralizer]
 theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S := fun g hg =>
   by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
 #align set.inv_mem_centralizer Set.inv_mem_centralizer
 #align set.neg_mem_add_centralizer Set.neg_mem_addCentralizer
+-/
 
+#print Set.add_mem_centralizer /-
 @[simp]
 theorem add_mem_centralizer [Distrib M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a + b ∈ centralizer S := fun c hc => by rw [add_mul, mul_add, ha c hc, hb c hc]
 #align set.add_mem_centralizer Set.add_mem_centralizer
+-/
 
+#print Set.neg_mem_centralizer /-
 @[simp]
 theorem neg_mem_centralizer [Mul M] [HasDistribNeg M] (ha : a ∈ centralizer S) :
     -a ∈ centralizer S := fun c hc => by rw [mul_neg, ha c hc, neg_mul]
 #align set.neg_mem_centralizer Set.neg_mem_centralizer
+-/
 
+#print Set.inv_mem_centralizer₀ /-
 @[simp]
 theorem inv_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S :=
   (eq_or_ne a 0).elim (fun h => by rw [h, inv_zero]; exact zero_mem_centralizer S) fun ha0 c hc =>
     by rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
 #align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀
+-/
 
+#print Set.div_mem_centralizer /-
 @[simp, to_additive sub_mem_add_centralizer]
 theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a / b ∈ centralizer S := by
@@ -113,13 +128,16 @@ theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ cen
   exact mul_mem_centralizer ha (inv_mem_centralizer hb)
 #align set.div_mem_centralizer Set.div_mem_centralizer
 #align set.sub_mem_add_centralizer Set.sub_mem_addCentralizer
+-/
 
+#print Set.div_mem_centralizer₀ /-
 @[simp]
 theorem div_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a / b ∈ centralizer S := by
   rw [div_eq_mul_inv]
   exact mul_mem_centralizer ha (inv_mem_centralizer₀ hb)
 #align set.div_mem_centralizer₀ Set.div_mem_centralizer₀
+-/
 
 #print Set.centralizer_subset /-
 @[to_additive add_centralizer_subset]
@@ -158,11 +176,13 @@ theorem centralizer_univ [Mul M] : centralizer univ = center M :=
 
 variable {M} (S)
 
+#print Set.centralizer_eq_univ /-
 @[simp, to_additive add_centralizer_eq_univ]
 theorem centralizer_eq_univ [CommSemigroup M] : centralizer S = univ :=
   Subset.antisymm (subset_univ _) fun x hx y hy => mul_comm y x
 #align set.centralizer_eq_univ Set.centralizer_eq_univ
 #align set.add_centralizer_eq_univ Set.addCentralizer_eq_univ
+-/
 
 end Set
 
@@ -172,6 +192,7 @@ section
 
 variable {M} [Semigroup M] (S)
 
+#print Subsemigroup.centralizer /-
 /-- The centralizer of a subset of a semigroup `M`. -/
 @[to_additive "The centralizer of a subset of an additive semigroup."]
 def centralizer : Subsemigroup M where
@@ -179,53 +200,68 @@ def centralizer : Subsemigroup M where
   mul_mem' a b := Set.mul_mem_centralizer
 #align subsemigroup.centralizer Subsemigroup.centralizer
 #align add_subsemigroup.centralizer AddSubsemigroup.centralizer
+-/
 
+#print Subsemigroup.coe_centralizer /-
 @[simp, norm_cast, to_additive]
 theorem coe_centralizer : ↑(centralizer S) = S.centralizer :=
   rfl
 #align subsemigroup.coe_centralizer Subsemigroup.coe_centralizer
 #align add_subsemigroup.coe_centralizer AddSubsemigroup.coe_centralizer
+-/
 
 variable {S}
 
+#print Subsemigroup.mem_centralizer_iff /-
 @[to_additive]
 theorem mem_centralizer_iff {z : M} : z ∈ centralizer S ↔ ∀ g ∈ S, g * z = z * g :=
   Iff.rfl
 #align subsemigroup.mem_centralizer_iff Subsemigroup.mem_centralizer_iff
 #align add_subsemigroup.mem_centralizer_iff AddSubsemigroup.mem_centralizer_iff
+-/
 
+#print Subsemigroup.decidableMemCentralizer /-
 @[to_additive]
 instance decidableMemCentralizer (a) [Decidable <| ∀ b ∈ S, b * a = a * b] :
     Decidable (a ∈ centralizer S) :=
   decidable_of_iff' _ mem_centralizer_iff
 #align subsemigroup.decidable_mem_centralizer Subsemigroup.decidableMemCentralizer
 #align add_subsemigroup.decidable_mem_centralizer AddSubsemigroup.decidableMemCentralizer
+-/
 
+#print Subsemigroup.center_le_centralizer /-
 @[to_additive]
 theorem center_le_centralizer (S) : center M ≤ centralizer S :=
   S.center_subset_centralizer
 #align subsemigroup.center_le_centralizer Subsemigroup.center_le_centralizer
 #align add_subsemigroup.center_le_centralizer AddSubsemigroup.center_le_centralizer
+-/
 
+#print Subsemigroup.centralizer_le /-
 @[to_additive]
 theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
   Set.centralizer_subset h
 #align subsemigroup.centralizer_le Subsemigroup.centralizer_le
 #align add_subsemigroup.centralizer_le AddSubsemigroup.centralizer_le
+-/
 
+#print Subsemigroup.centralizer_eq_top_iff_subset /-
 @[simp, to_additive]
 theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M :=
   SetLike.ext'_iff.trans Set.centralizer_eq_top_iff_subset
 #align subsemigroup.centralizer_eq_top_iff_subset Subsemigroup.centralizer_eq_top_iff_subset
 #align add_subsemigroup.centralizer_eq_top_iff_subset AddSubsemigroup.centralizer_eq_top_iff_subset
+-/
 
 variable (M)
 
+#print Subsemigroup.centralizer_univ /-
 @[simp, to_additive]
 theorem centralizer_univ : centralizer Set.univ = center M :=
   SetLike.ext' (Set.centralizer_univ M)
 #align subsemigroup.centralizer_univ Subsemigroup.centralizer_univ
 #align add_subsemigroup.centralizer_univ AddSubsemigroup.centralizer_univ
+-/
 
 end

bump to nightly-2023-06-11-17

mathlib commit https://github.com/leanprover-community/mathlib/commit/c471da714c044131b90c133701e51b877c246677

e85a8bfe

Diff

@@ -51,7 +51,7 @@ variable {S}
 theorem mem_centralizer_iff [Mul M] {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m :=
   Iff.rfl
 #align set.mem_centralizer_iff Set.mem_centralizer_iff
-#align set.mem_add_centralizer Set.mem_add_centralizer
+#align set.mem_add_centralizer Set.mem_addCentralizer
 -/
 
 #print Set.decidableMemCentralizer /-
@@ -68,7 +68,7 @@ variable (S)
 theorem one_mem_centralizer [MulOneClass M] : (1 : M) ∈ centralizer S := by
   simp [mem_centralizer_iff]
 #align set.one_mem_centralizer Set.one_mem_centralizer
-#align set.zero_mem_add_centralizer Set.zero_mem_add_centralizer
+#align set.zero_mem_add_centralizer Set.zero_mem_addCentralizer
 
 @[simp]
 theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
@@ -82,13 +82,13 @@ theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈
     a * b ∈ centralizer S := fun g hg => by
   rw [mul_assoc, ← hb g hg, ← mul_assoc, ha g hg, mul_assoc]
 #align set.mul_mem_centralizer Set.mul_mem_centralizer
-#align set.add_mem_add_centralizer Set.add_mem_add_centralizer
+#align set.add_mem_add_centralizer Set.add_mem_addCentralizer
 
 @[simp, to_additive neg_mem_add_centralizer]
 theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S := fun g hg =>
   by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
 #align set.inv_mem_centralizer Set.inv_mem_centralizer
-#align set.neg_mem_add_centralizer Set.neg_mem_add_centralizer
+#align set.neg_mem_add_centralizer Set.neg_mem_addCentralizer
 
 @[simp]
 theorem add_mem_centralizer [Distrib M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
@@ -112,7 +112,7 @@ theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ cen
   rw [div_eq_mul_inv]
   exact mul_mem_centralizer ha (inv_mem_centralizer hb)
 #align set.div_mem_centralizer Set.div_mem_centralizer
-#align set.sub_mem_add_centralizer Set.sub_mem_add_centralizer
+#align set.sub_mem_add_centralizer Set.sub_mem_addCentralizer
 
 @[simp]
 theorem div_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
@@ -126,7 +126,7 @@ theorem div_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) (hb
 theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer S := fun t ht s hs =>
   ht s (h hs)
 #align set.centralizer_subset Set.centralizer_subset
-#align set.add_centralizer_subset Set.add_centralizer_subset
+#align set.add_centralizer_subset Set.addCentralizer_subset
 -/
 
 #print Set.center_subset_centralizer /-
@@ -153,7 +153,7 @@ variable (M)
 theorem centralizer_univ [Mul M] : centralizer univ = center M :=
   Subset.antisymm (fun a ha b => ha b (Set.mem_univ b)) fun a ha b hb => ha b
 #align set.centralizer_univ Set.centralizer_univ
-#align set.add_centralizer_univ Set.add_centralizer_univ
+#align set.add_centralizer_univ Set.addCentralizer_univ
 -/
 
 variable {M} (S)
@@ -162,7 +162,7 @@ variable {M} (S)
 theorem centralizer_eq_univ [CommSemigroup M] : centralizer S = univ :=
   Subset.antisymm (subset_univ _) fun x hx y hy => mul_comm y x
 #align set.centralizer_eq_univ Set.centralizer_eq_univ
-#align set.add_centralizer_eq_univ Set.add_centralizer_eq_univ
+#align set.add_centralizer_eq_univ Set.addCentralizer_eq_univ
 
 end Set

bump to nightly-2023-06-10-19

mathlib commit https://github.com/leanprover-community/mathlib/commit/a3e83f0fa4391c8740f7d773a7a9b74e311ae2a3

024fdb7b

Diff

@@ -129,18 +129,22 @@ theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer
 #align set.add_centralizer_subset Set.add_centralizer_subset
 -/
 
+#print Set.center_subset_centralizer /-
 @[to_additive add_center_subset_add_centralizer]
 theorem center_subset_centralizer [Mul M] (S : Set M) : Set.center M ⊆ S.centralizer :=
   fun x hx m _ => hx m
 #align set.center_subset_centralizer Set.center_subset_centralizer
-#align set.add_center_subset_add_centralizer Set.add_center_subset_add_centralizer
+#align set.add_center_subset_add_centralizer Set.addCenter_subset_addCentralizer
+-/
 
+#print Set.centralizer_eq_top_iff_subset /-
 @[simp, to_additive add_centralizer_eq_top_iff_subset]
 theorem centralizer_eq_top_iff_subset {s : Set M} [Mul M] :
     centralizer s = Set.univ ↔ s ⊆ center M :=
   eq_top_iff.trans <| ⟨fun h x hx g => (h trivial _ hx).symm, fun h x _ m hm => (h hm x).symm⟩
 #align set.centralizer_eq_top_iff_subset Set.centralizer_eq_top_iff_subset
-#align set.add_centralizer_eq_top_iff_subset Set.add_centralizer_eq_top_iff_subset
+#align set.add_centralizer_eq_top_iff_subset Set.addCentralizer_eq_top_iff_subset
+-/
 
 variable (M)

bump to nightly-2023-06-10-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/a3e83f0fa4391c8740f7d773a7a9b74e311ae2a3

e13a28eb

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
 
 ! This file was ported from Lean 3 source module group_theory.subsemigroup.centralizer
-! leanprover-community/mathlib commit b915e9392ecb2a861e1e766f0e1df6ac481188ca
+! leanprover-community/mathlib commit cc67cd75b4e54191e13c2e8d722289a89e67e4fa
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -129,15 +129,18 @@ theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer
 #align set.add_centralizer_subset Set.add_centralizer_subset
 -/
 
+@[to_additive add_center_subset_add_centralizer]
 theorem center_subset_centralizer [Mul M] (S : Set M) : Set.center M ⊆ S.centralizer :=
   fun x hx m _ => hx m
 #align set.center_subset_centralizer Set.center_subset_centralizer
+#align set.add_center_subset_add_centralizer Set.add_center_subset_add_centralizer
 
-@[simp]
+@[simp, to_additive add_centralizer_eq_top_iff_subset]
 theorem centralizer_eq_top_iff_subset {s : Set M} [Mul M] :
     centralizer s = Set.univ ↔ s ⊆ center M :=
   eq_top_iff.trans <| ⟨fun h x hx g => (h trivial _ hx).symm, fun h x _ m hm => (h hm x).symm⟩
 #align set.centralizer_eq_top_iff_subset Set.centralizer_eq_top_iff_subset
+#align set.add_centralizer_eq_top_iff_subset Set.add_centralizer_eq_top_iff_subset
 
 variable (M)
 
@@ -194,9 +197,11 @@ instance decidableMemCentralizer (a) [Decidable <| ∀ b ∈ S, b * a = a * b] :
 #align subsemigroup.decidable_mem_centralizer Subsemigroup.decidableMemCentralizer
 #align add_subsemigroup.decidable_mem_centralizer AddSubsemigroup.decidableMemCentralizer
 
+@[to_additive]
 theorem center_le_centralizer (S) : center M ≤ centralizer S :=
   S.center_subset_centralizer
 #align subsemigroup.center_le_centralizer Subsemigroup.center_le_centralizer
+#align add_subsemigroup.center_le_centralizer AddSubsemigroup.center_le_centralizer
 
 @[to_additive]
 theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
@@ -204,10 +209,11 @@ theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
 #align subsemigroup.centralizer_le Subsemigroup.centralizer_le
 #align add_subsemigroup.centralizer_le AddSubsemigroup.centralizer_le
 
-@[simp]
+@[simp, to_additive]
 theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M :=
   SetLike.ext'_iff.trans Set.centralizer_eq_top_iff_subset
 #align subsemigroup.centralizer_eq_top_iff_subset Subsemigroup.centralizer_eq_top_iff_subset
+#align add_subsemigroup.centralizer_eq_top_iff_subset AddSubsemigroup.centralizer_eq_top_iff_subset
 
 variable (M)

b915e939

bump to nightly-2023-06-09-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/7e5137f579de09a059a5ce98f364a04e221aabf0

fe176e9b

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
 
 ! This file was ported from Lean 3 source module group_theory.subsemigroup.centralizer
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
+! leanprover-community/mathlib commit b915e9392ecb2a861e1e766f0e1df6ac481188ca
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -129,6 +129,16 @@ theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer
 #align set.add_centralizer_subset Set.add_centralizer_subset
 -/
 
+theorem center_subset_centralizer [Mul M] (S : Set M) : Set.center M ⊆ S.centralizer :=
+  fun x hx m _ => hx m
+#align set.center_subset_centralizer Set.center_subset_centralizer
+
+@[simp]
+theorem centralizer_eq_top_iff_subset {s : Set M} [Mul M] :
+    centralizer s = Set.univ ↔ s ⊆ center M :=
+  eq_top_iff.trans <| ⟨fun h x hx g => (h trivial _ hx).symm, fun h x _ m hm => (h hm x).symm⟩
+#align set.centralizer_eq_top_iff_subset Set.centralizer_eq_top_iff_subset
+
 variable (M)
 
 #print Set.centralizer_univ /-
@@ -184,12 +194,21 @@ instance decidableMemCentralizer (a) [Decidable <| ∀ b ∈ S, b * a = a * b] :
 #align subsemigroup.decidable_mem_centralizer Subsemigroup.decidableMemCentralizer
 #align add_subsemigroup.decidable_mem_centralizer AddSubsemigroup.decidableMemCentralizer
 
+theorem center_le_centralizer (S) : center M ≤ centralizer S :=
+  S.center_subset_centralizer
+#align subsemigroup.center_le_centralizer Subsemigroup.center_le_centralizer
+
 @[to_additive]
 theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
   Set.centralizer_subset h
 #align subsemigroup.centralizer_le Subsemigroup.centralizer_le
 #align add_subsemigroup.centralizer_le AddSubsemigroup.centralizer_le
 
+@[simp]
+theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M :=
+  SetLike.ext'_iff.trans Set.centralizer_eq_top_iff_subset
+#align subsemigroup.centralizer_eq_top_iff_subset Subsemigroup.centralizer_eq_top_iff_subset
+
 variable (M)
 
 @[simp, to_additive]

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -39,7 +39,7 @@ variable (S)
 /-- The centralizer of a subset of a magma. -/
 @[to_additive add_centralizer " The centralizer of a subset of an additive magma. "]
 def centralizer [Mul M] : Set M :=
-  { c | ∀ m ∈ S, m * c = c * m }
+  {c | ∀ m ∈ S, m * c = c * m}
 #align set.centralizer Set.centralizer
 #align set.add_centralizer Set.addCentralizer
 -/

bump to nightly-2023-05-28-06

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

ba5d8b97

Diff

@@ -64,24 +64,12 @@ instance decidableMemCentralizer [Mul M] [∀ a : M, Decidable <| ∀ b ∈ S, b
 
 variable (S)
 
-/- warning: set.one_mem_centralizer -> Set.one_mem_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : MulOneClass.{u1} M], Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_1)))) (Set.centralizer.{u1} M S (MulOneClass.toHasMul.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : MulOneClass.{u1} M], Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (MulOneClass.toOne.{u1} M _inst_1))) (Set.centralizer.{u1} M S (MulOneClass.toMul.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align set.one_mem_centralizer Set.one_mem_centralizerₓ'. -/
 @[simp, to_additive zero_mem_add_centralizer]
 theorem one_mem_centralizer [MulOneClass M] : (1 : M) ∈ centralizer S := by
   simp [mem_centralizer_iff]
 #align set.one_mem_centralizer Set.one_mem_centralizer
 #align set.zero_mem_add_centralizer Set.zero_mem_add_centralizer
 
-/- warning: set.zero_mem_centralizer -> Set.zero_mem_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : MulZeroClass.{u1} M], Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (OfNat.ofNat.{u1} M 0 (OfNat.mk.{u1} M 0 (Zero.zero.{u1} M (MulZeroClass.toHasZero.{u1} M _inst_1)))) (Set.centralizer.{u1} M S (MulZeroClass.toHasMul.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : MulZeroClass.{u1} M], Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (OfNat.ofNat.{u1} M 0 (Zero.toOfNat0.{u1} M (MulZeroClass.toZero.{u1} M _inst_1))) (Set.centralizer.{u1} M S (MulZeroClass.toMul.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align set.zero_mem_centralizer Set.zero_mem_centralizerₓ'. -/
 @[simp]
 theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
   simp [mem_centralizer_iff]
@@ -89,12 +77,6 @@ theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
 
 variable {S} {a b : M}
 
-/- warning: set.mul_mem_centralizer -> Set.mul_mem_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : Semigroup.{u1} M], (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (Set.centralizer.{u1} M S (Semigroup.toHasMul.{u1} M _inst_1))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (Set.centralizer.{u1} M S (Semigroup.toHasMul.{u1} M _inst_1))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) a b) (Set.centralizer.{u1} M S (Semigroup.toHasMul.{u1} M _inst_1)))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : Semigroup.{u1} M], (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (Set.centralizer.{u1} M S (Semigroup.toMul.{u1} M _inst_1))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (Set.centralizer.{u1} M S (Semigroup.toMul.{u1} M _inst_1))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toMul.{u1} M _inst_1)) a b) (Set.centralizer.{u1} M S (Semigroup.toMul.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align set.mul_mem_centralizer Set.mul_mem_centralizerₓ'. -/
 @[simp, to_additive add_mem_add_centralizer]
 theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a * b ∈ centralizer S := fun g hg => by
@@ -102,58 +84,28 @@ theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈
 #align set.mul_mem_centralizer Set.mul_mem_centralizer
 #align set.add_mem_add_centralizer Set.add_mem_add_centralizer
 
-/- warning: set.inv_mem_centralizer -> Set.inv_mem_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} [_inst_1 : Group.{u1} M], (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (Set.centralizer.{u1} M S (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1)))))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1)) a) (Set.centralizer.{u1} M S (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1))))))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} [_inst_1 : Group.{u1} M], (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (Set.centralizer.{u1} M S (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1)))))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (Inv.inv.{u1} M (InvOneClass.toInv.{u1} M (DivInvOneMonoid.toInvOneClass.{u1} M (DivisionMonoid.toDivInvOneMonoid.{u1} M (Group.toDivisionMonoid.{u1} M _inst_1)))) a) (Set.centralizer.{u1} M S (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align set.inv_mem_centralizer Set.inv_mem_centralizerₓ'. -/
 @[simp, to_additive neg_mem_add_centralizer]
 theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S := fun g hg =>
   by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
 #align set.inv_mem_centralizer Set.inv_mem_centralizer
 #align set.neg_mem_add_centralizer Set.neg_mem_add_centralizer
 
-/- warning: set.add_mem_centralizer -> Set.add_mem_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : Distrib.{u1} M], (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (Set.centralizer.{u1} M S (Distrib.toHasMul.{u1} M _inst_1))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (Set.centralizer.{u1} M S (Distrib.toHasMul.{u1} M _inst_1))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (Distrib.toHasAdd.{u1} M _inst_1)) a b) (Set.centralizer.{u1} M S (Distrib.toHasMul.{u1} M _inst_1)))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : Distrib.{u1} M], (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (Set.centralizer.{u1} M S (Distrib.toMul.{u1} M _inst_1))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (Set.centralizer.{u1} M S (Distrib.toMul.{u1} M _inst_1))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HAdd.hAdd.{u1, u1, u1} M M M (instHAdd.{u1} M (Distrib.toAdd.{u1} M _inst_1)) a b) (Set.centralizer.{u1} M S (Distrib.toMul.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align set.add_mem_centralizer Set.add_mem_centralizerₓ'. -/
 @[simp]
 theorem add_mem_centralizer [Distrib M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a + b ∈ centralizer S := fun c hc => by rw [add_mul, mul_add, ha c hc, hb c hc]
 #align set.add_mem_centralizer Set.add_mem_centralizer
 
-/- warning: set.neg_mem_centralizer -> Set.neg_mem_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} [_inst_1 : Mul.{u1} M] [_inst_2 : HasDistribNeg.{u1} M _inst_1], (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (Set.centralizer.{u1} M S _inst_1)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (Neg.neg.{u1} M (InvolutiveNeg.toHasNeg.{u1} M (HasDistribNeg.toHasInvolutiveNeg.{u1} M _inst_1 _inst_2)) a) (Set.centralizer.{u1} M S _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} [_inst_1 : Mul.{u1} M] [_inst_2 : HasDistribNeg.{u1} M _inst_1], (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (Set.centralizer.{u1} M S _inst_1)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (Neg.neg.{u1} M (InvolutiveNeg.toNeg.{u1} M (HasDistribNeg.toInvolutiveNeg.{u1} M _inst_1 _inst_2)) a) (Set.centralizer.{u1} M S _inst_1))
-Case conversion may be inaccurate. Consider using '#align set.neg_mem_centralizer Set.neg_mem_centralizerₓ'. -/
 @[simp]
 theorem neg_mem_centralizer [Mul M] [HasDistribNeg M] (ha : a ∈ centralizer S) :
     -a ∈ centralizer S := fun c hc => by rw [mul_neg, ha c hc, neg_mul]
 #align set.neg_mem_centralizer Set.neg_mem_centralizer
 
-/- warning: set.inv_mem_centralizer₀ -> Set.inv_mem_centralizer₀ is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} [_inst_1 : GroupWithZero.{u1} M], (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (Set.centralizer.{u1} M S (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1)))))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (Inv.inv.{u1} M (DivInvMonoid.toHasInv.{u1} M (GroupWithZero.toDivInvMonoid.{u1} M _inst_1)) a) (Set.centralizer.{u1} M S (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1))))))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} [_inst_1 : GroupWithZero.{u1} M], (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (Set.centralizer.{u1} M S (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1)))))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (Inv.inv.{u1} M (GroupWithZero.toInv.{u1} M _inst_1) a) (Set.centralizer.{u1} M S (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀ₓ'. -/
 @[simp]
 theorem inv_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S :=
   (eq_or_ne a 0).elim (fun h => by rw [h, inv_zero]; exact zero_mem_centralizer S) fun ha0 c hc =>
     by rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
 #align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀
 
-/- warning: set.div_mem_centralizer -> Set.div_mem_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : Group.{u1} M], (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (Set.centralizer.{u1} M S (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1)))))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (Set.centralizer.{u1} M S (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1)))))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HDiv.hDiv.{u1, u1, u1} M M M (instHDiv.{u1} M (DivInvMonoid.toHasDiv.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1))) a b) (Set.centralizer.{u1} M S (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1))))))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : Group.{u1} M], (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (Set.centralizer.{u1} M S (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1)))))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (Set.centralizer.{u1} M S (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1)))))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HDiv.hDiv.{u1, u1, u1} M M M (instHDiv.{u1} M (DivInvMonoid.toDiv.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1))) a b) (Set.centralizer.{u1} M S (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M (DivInvMonoid.toMonoid.{u1} M (Group.toDivInvMonoid.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align set.div_mem_centralizer Set.div_mem_centralizerₓ'. -/
 @[simp, to_additive sub_mem_add_centralizer]
 theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a / b ∈ centralizer S := by
@@ -162,12 +114,6 @@ theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ cen
 #align set.div_mem_centralizer Set.div_mem_centralizer
 #align set.sub_mem_add_centralizer Set.sub_mem_add_centralizer
 
-/- warning: set.div_mem_centralizer₀ -> Set.div_mem_centralizer₀ is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : GroupWithZero.{u1} M], (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (Set.centralizer.{u1} M S (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1)))))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (Set.centralizer.{u1} M S (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1)))))) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HDiv.hDiv.{u1, u1, u1} M M M (instHDiv.{u1} M (DivInvMonoid.toHasDiv.{u1} M (GroupWithZero.toDivInvMonoid.{u1} M _inst_1))) a b) (Set.centralizer.{u1} M S (MulZeroClass.toHasMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1))))))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {a : M} {b : M} [_inst_1 : GroupWithZero.{u1} M], (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (Set.centralizer.{u1} M S (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1)))))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (Set.centralizer.{u1} M S (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1)))))) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HDiv.hDiv.{u1, u1, u1} M M M (instHDiv.{u1} M (GroupWithZero.toDiv.{u1} M _inst_1)) a b) (Set.centralizer.{u1} M S (MulZeroClass.toMul.{u1} M (MulZeroOneClass.toMulZeroClass.{u1} M (MonoidWithZero.toMulZeroOneClass.{u1} M (GroupWithZero.toMonoidWithZero.{u1} M _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align set.div_mem_centralizer₀ Set.div_mem_centralizer₀ₓ'. -/
 @[simp]
 theorem div_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a / b ∈ centralizer S := by
@@ -195,12 +141,6 @@ theorem centralizer_univ [Mul M] : centralizer univ = center M :=
 
 variable {M} (S)
 
-/- warning: set.centralizer_eq_univ -> Set.centralizer_eq_univ is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : CommSemigroup.{u1} M], Eq.{succ u1} (Set.{u1} M) (Set.centralizer.{u1} M S (Semigroup.toHasMul.{u1} M (CommSemigroup.toSemigroup.{u1} M _inst_1))) (Set.univ.{u1} M)
-but is expected to have type
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : CommSemigroup.{u1} M], Eq.{succ u1} (Set.{u1} M) (Set.centralizer.{u1} M S (Semigroup.toMul.{u1} M (CommSemigroup.toSemigroup.{u1} M _inst_1))) (Set.univ.{u1} M)
-Case conversion may be inaccurate. Consider using '#align set.centralizer_eq_univ Set.centralizer_eq_univₓ'. -/
 @[simp, to_additive add_centralizer_eq_univ]
 theorem centralizer_eq_univ [CommSemigroup M] : centralizer S = univ :=
   Subset.antisymm (subset_univ _) fun x hx y hy => mul_comm y x
@@ -215,12 +155,6 @@ section
 
 variable {M} [Semigroup M] (S)
 
-/- warning: subsemigroup.centralizer -> Subsemigroup.centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}}, (Set.{u1} M) -> (forall [_inst_1 : Semigroup.{u1} M], Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}}, (Set.{u1} M) -> (forall [_inst_1 : Semigroup.{u1} M], Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align subsemigroup.centralizer Subsemigroup.centralizerₓ'. -/
 /-- The centralizer of a subset of a semigroup `M`. -/
 @[to_additive "The centralizer of a subset of an additive semigroup."]
 def centralizer : Subsemigroup M where
@@ -229,12 +163,6 @@ def centralizer : Subsemigroup M where
 #align subsemigroup.centralizer Subsemigroup.centralizer
 #align add_subsemigroup.centralizer AddSubsemigroup.centralizer
 
-/- warning: subsemigroup.coe_centralizer -> Subsemigroup.coe_centralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : Semigroup.{u1} M], Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) M (Subsemigroup.setLike.{u1} M (Semigroup.toHasMul.{u1} M _inst_1))))) (Subsemigroup.centralizer.{u1} M S _inst_1)) (Set.centralizer.{u1} M S (Semigroup.toHasMul.{u1} M _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} (S : Set.{u1} M) [_inst_1 : Semigroup.{u1} M], Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) M (Subsemigroup.instSetLikeSubsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (Subsemigroup.centralizer.{u1} M S _inst_1)) (Set.centralizer.{u1} M S (Semigroup.toMul.{u1} M _inst_1))
-Case conversion may be inaccurate. Consider using '#align subsemigroup.coe_centralizer Subsemigroup.coe_centralizerₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_centralizer : ↑(centralizer S) = S.centralizer :=
   rfl
@@ -243,24 +171,12 @@ theorem coe_centralizer : ↑(centralizer S) = S.centralizer :=
 
 variable {S}
 
-/- warning: subsemigroup.mem_centralizer_iff -> Subsemigroup.mem_centralizer_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} [_inst_1 : Semigroup.{u1} M] {z : M}, Iff (Membership.Mem.{u1, u1} M (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) M (Subsemigroup.setLike.{u1} M (Semigroup.toHasMul.{u1} M _inst_1))) z (Subsemigroup.centralizer.{u1} M S _inst_1)) (forall (g : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) g S) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) g z) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) z g)))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} [_inst_1 : Semigroup.{u1} M] {z : M}, Iff (Membership.mem.{u1, u1} M (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) M (Subsemigroup.instSetLikeSubsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1))) z (Subsemigroup.centralizer.{u1} M S _inst_1)) (forall (g : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) g S) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toMul.{u1} M _inst_1)) g z) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toMul.{u1} M _inst_1)) z g)))
-Case conversion may be inaccurate. Consider using '#align subsemigroup.mem_centralizer_iff Subsemigroup.mem_centralizer_iffₓ'. -/
 @[to_additive]
 theorem mem_centralizer_iff {z : M} : z ∈ centralizer S ↔ ∀ g ∈ S, g * z = z * g :=
   Iff.rfl
 #align subsemigroup.mem_centralizer_iff Subsemigroup.mem_centralizer_iff
 #align add_subsemigroup.mem_centralizer_iff AddSubsemigroup.mem_centralizer_iff
 
-/- warning: subsemigroup.decidable_mem_centralizer -> Subsemigroup.decidableMemCentralizer is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} [_inst_1 : Semigroup.{u1} M] (a : M) [_inst_2 : Decidable (forall (b : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b S) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) b a) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) a b)))], Decidable (Membership.Mem.{u1, u1} M (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) M (Subsemigroup.setLike.{u1} M (Semigroup.toHasMul.{u1} M _inst_1))) a (Subsemigroup.centralizer.{u1} M S _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} [_inst_1 : Semigroup.{u1} M] (a : M) [_inst_2 : Decidable (forall (b : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b S) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toMul.{u1} M _inst_1)) b a) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (Semigroup.toMul.{u1} M _inst_1)) a b)))], Decidable (Membership.mem.{u1, u1} M (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) M (Subsemigroup.instSetLikeSubsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1))) a (Subsemigroup.centralizer.{u1} M S _inst_1))
-Case conversion may be inaccurate. Consider using '#align subsemigroup.decidable_mem_centralizer Subsemigroup.decidableMemCentralizerₓ'. -/
 @[to_additive]
 instance decidableMemCentralizer (a) [Decidable <| ∀ b ∈ S, b * a = a * b] :
     Decidable (a ∈ centralizer S) :=
@@ -268,12 +184,6 @@ instance decidableMemCentralizer (a) [Decidable <| ∀ b ∈ S, b * a = a * b] :
 #align subsemigroup.decidable_mem_centralizer Subsemigroup.decidableMemCentralizer
 #align add_subsemigroup.decidable_mem_centralizer AddSubsemigroup.decidableMemCentralizer
 
-/- warning: subsemigroup.centralizer_le -> Subsemigroup.centralizer_le is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {T : Set.{u1} M} [_inst_1 : Semigroup.{u1} M], (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) S T) -> (LE.le.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) M (Subsemigroup.setLike.{u1} M (Semigroup.toHasMul.{u1} M _inst_1))))) (Subsemigroup.centralizer.{u1} M T _inst_1) (Subsemigroup.centralizer.{u1} M S _inst_1))
-but is expected to have type
-  forall {M : Type.{u1}} {S : Set.{u1} M} {T : Set.{u1} M} [_inst_1 : Semigroup.{u1} M], (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) S T) -> (LE.le.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (Preorder.toLE.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (Subsemigroup.instCompleteLatticeSubsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)))))) (Subsemigroup.centralizer.{u1} M T _inst_1) (Subsemigroup.centralizer.{u1} M S _inst_1))
-Case conversion may be inaccurate. Consider using '#align subsemigroup.centralizer_le Subsemigroup.centralizer_leₓ'. -/
 @[to_additive]
 theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
   Set.centralizer_subset h
@@ -282,12 +192,6 @@ theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
 
 variable (M)
 
-/- warning: subsemigroup.centralizer_univ -> Subsemigroup.centralizer_univ is a dubious translation:
-lean 3 declaration is
-  forall (M : Type.{u1}) [_inst_1 : Semigroup.{u1} M], Eq.{succ u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (Subsemigroup.centralizer.{u1} M (Set.univ.{u1} M) _inst_1) (Subsemigroup.center.{u1} M _inst_1)
-but is expected to have type
-  forall (M : Type.{u1}) [_inst_1 : Semigroup.{u1} M], Eq.{succ u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (Subsemigroup.centralizer.{u1} M (Set.univ.{u1} M) _inst_1) (Subsemigroup.center.{u1} M _inst_1)
-Case conversion may be inaccurate. Consider using '#align subsemigroup.centralizer_univ Subsemigroup.centralizer_univₓ'. -/
 @[simp, to_additive]
 theorem centralizer_univ : centralizer Set.univ = center M :=
   SetLike.ext' (Set.centralizer_univ M)

bump to nightly-2023-05-28-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/917c3c072e487b3cccdbfeff17e75b40e45f66cb

6797a637

Diff

@@ -144,12 +144,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀ₓ'. -/
 @[simp]
 theorem inv_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S :=
-  (eq_or_ne a 0).elim
-    (fun h => by
-      rw [h, inv_zero]
-      exact zero_mem_centralizer S)
-    fun ha0 c hc => by
-    rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
+  (eq_or_ne a 0).elim (fun h => by rw [h, inv_zero]; exact zero_mem_centralizer S) fun ha0 c hc =>
+    by rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
 #align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀
 
 /- warning: set.div_mem_centralizer -> Set.div_mem_centralizer is a dubious translation:

bump to nightly-2023-05-16-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8

9cb92e8c

Diff

@@ -274,7 +274,7 @@ instance decidableMemCentralizer (a) [Decidable <| ∀ b ∈ S, b * a = a * b] :
 
 /- warning: subsemigroup.centralizer_le -> Subsemigroup.centralizer_le is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} {S : Set.{u1} M} {T : Set.{u1} M} [_inst_1 : Semigroup.{u1} M], (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) S T) -> (LE.le.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (Preorder.toLE.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) M (Subsemigroup.setLike.{u1} M (Semigroup.toHasMul.{u1} M _inst_1))))) (Subsemigroup.centralizer.{u1} M T _inst_1) (Subsemigroup.centralizer.{u1} M S _inst_1))
+  forall {M : Type.{u1}} {S : Set.{u1} M} {T : Set.{u1} M} [_inst_1 : Semigroup.{u1} M], (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) S T) -> (LE.le.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Subsemigroup.{u1} M (Semigroup.toHasMul.{u1} M _inst_1)) M (Subsemigroup.setLike.{u1} M (Semigroup.toHasMul.{u1} M _inst_1))))) (Subsemigroup.centralizer.{u1} M T _inst_1) (Subsemigroup.centralizer.{u1} M S _inst_1))
 but is expected to have type
   forall {M : Type.{u1}} {S : Set.{u1} M} {T : Set.{u1} M} [_inst_1 : Semigroup.{u1} M], (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) S T) -> (LE.le.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (Preorder.toLE.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)) (Subsemigroup.instCompleteLatticeSubsemigroup.{u1} M (Semigroup.toMul.{u1} M _inst_1)))))) (Subsemigroup.centralizer.{u1} M T _inst_1) (Subsemigroup.centralizer.{u1} M S _inst_1))
 Case conversion may be inaccurate. Consider using '#align subsemigroup.centralizer_le Subsemigroup.centralizer_leₓ'. -/

bump to nightly-2023-02-21-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/bd9851ca476957ea4549eb19b40e7b5ade9428cc

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: refactor to avoid importing Ring for Group topics (#11913)

This is a far from a complete success at the PR title, but it makes a fair bit of progress, and then guards this with appropriate assert_not_exists Ring statements.

It also breaks apart the Mathlib.GroupTheory.Subsemigroup.[Center|Centralizer] files, to pull the Set.center and Set.centralizer declarations into their own files not depending on Subsemigroup.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

8e052acc

Diff

@@ -4,17 +4,16 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
 -/
 import Mathlib.GroupTheory.Subsemigroup.Center
+import Mathlib.Algebra.Group.Centralizer
 
 #align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"
 
 /-!
-# Centralizers of magmas and semigroups
+# Centralizers in semigroups, as subsemigroups.
 
 ## Main definitions
 
-* `Set.centralizer`: the centralizer of a subset of a magma
 * `Subsemigroup.centralizer`: the centralizer of a subset of a semigroup
-* `Set.addCentralizer`: the centralizer of a subset of an additive magma
 * `AddSubsemigroup.centralizer`: the centralizer of a subset of an additive semigroup
 
 We provide `Monoid.centralizer`, `AddMonoid.centralizer`, `Subgroup.centralizer`, and
@@ -23,135 +22,6 @@ We provide `Monoid.centralizer`, `AddMonoid.centralizer`, `Subgroup.centralizer`
 
 
 variable {M : Type*} {S T : Set M}
-
-namespace Set
-
-variable (S)
-
-/-- The centralizer of a subset of a magma. -/
-@[to_additive addCentralizer " The centralizer of a subset of an additive magma. "]
-def centralizer [Mul M] : Set M :=
-  { c | ∀ m ∈ S, m * c = c * m }
-#align set.centralizer Set.centralizer
-#align set.add_centralizer Set.addCentralizer
-
-variable {S}
-
-@[to_additive mem_addCentralizer]
-theorem mem_centralizer_iff [Mul M] {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m :=
-  Iff.rfl
-#align set.mem_centralizer_iff Set.mem_centralizer_iff
-#align set.mem_add_centralizer Set.mem_addCentralizer
-
-@[to_additive decidableMemAddCentralizer]
-instance decidableMemCentralizer [Mul M] [∀ a : M, Decidable <| ∀ b ∈ S, b * a = a * b] :
-    DecidablePred (· ∈ centralizer S) := fun _ => decidable_of_iff' _ mem_centralizer_iff
-#align set.decidable_mem_centralizer Set.decidableMemCentralizer
-#align set.decidable_mem_add_centralizer Set.decidableMemAddCentralizer
-
-variable (S)
-
-@[to_additive (attr := simp) zero_mem_addCentralizer]
-theorem one_mem_centralizer [MulOneClass M] : (1 : M) ∈ centralizer S := by
-  simp [mem_centralizer_iff]
-#align set.one_mem_centralizer Set.one_mem_centralizer
-#align set.zero_mem_add_centralizer Set.zero_mem_addCentralizer
-
-@[simp]
-theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
-  simp [mem_centralizer_iff]
-#align set.zero_mem_centralizer Set.zero_mem_centralizer
-
-variable {S} {a b : M}
-
-@[to_additive (attr := simp) add_mem_addCentralizer]
-theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
-    a * b ∈ centralizer S := fun g hg => by
-  rw [mul_assoc, ← hb g hg, ← mul_assoc, ha g hg, mul_assoc]
-#align set.mul_mem_centralizer Set.mul_mem_centralizer
-#align set.add_mem_add_centralizer Set.add_mem_addCentralizer
-
-@[to_additive (attr := simp) neg_mem_addCentralizer]
-theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S :=
-  fun g hg => by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
-#align set.inv_mem_centralizer Set.inv_mem_centralizer
-#align set.neg_mem_add_centralizer Set.neg_mem_addCentralizer
-
-@[simp]
-theorem add_mem_centralizer [Distrib M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
-    a + b ∈ centralizer S := fun c hc => by rw [add_mul, mul_add, ha c hc, hb c hc]
-#align set.add_mem_centralizer Set.add_mem_centralizer
-
-@[simp]
-theorem neg_mem_centralizer [Mul M] [HasDistribNeg M] (ha : a ∈ centralizer S) :
-    -a ∈ centralizer S := fun c hc => by rw [mul_neg, ha c hc, neg_mul]
-#align set.neg_mem_centralizer Set.neg_mem_centralizer
-
-@[simp]
-theorem inv_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S :=
-  (eq_or_ne a 0).elim
-    (fun h => by
-      rw [h, inv_zero]
-      exact zero_mem_centralizer S)
-    fun ha0 c hc => by
-    rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
-#align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀
-
-@[to_additive (attr := simp) sub_mem_addCentralizer]
-theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
-    a / b ∈ centralizer S := by
-  rw [div_eq_mul_inv]
-  exact mul_mem_centralizer ha (inv_mem_centralizer hb)
-#align set.div_mem_centralizer Set.div_mem_centralizer
-#align set.sub_mem_add_centralizer Set.sub_mem_addCentralizer
-
-@[simp]
-theorem div_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
-    a / b ∈ centralizer S := by
-  rw [div_eq_mul_inv]
-  exact mul_mem_centralizer ha (inv_mem_centralizer₀ hb)
-#align set.div_mem_centralizer₀ Set.div_mem_centralizer₀
-
-@[to_additive addCentralizer_subset]
-theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer S := fun _ ht s hs =>
-  ht s (h hs)
-#align set.centralizer_subset Set.centralizer_subset
-#align set.add_centralizer_subset Set.addCentralizer_subset
-
-@[to_additive addCenter_subset_addCentralizer]
-theorem center_subset_centralizer [Mul M] (S : Set M) : Set.center M ⊆ S.centralizer :=
-  fun _ hx m _ => (hx.comm m).symm
-#align set.center_subset_centralizer Set.center_subset_centralizer
-#align set.add_center_subset_add_centralizer Set.addCenter_subset_addCentralizer
-
-@[to_additive (attr := simp) addCentralizer_eq_top_iff_subset]
-theorem centralizer_eq_top_iff_subset {s : Set M} [Semigroup M] :
-    centralizer s = Set.univ ↔ s ⊆ center M :=
-  eq_top_iff.trans <| ⟨
-    fun h _ hx => Semigroup.mem_center_iff.mpr fun _ => by rw [h trivial _ hx],
-    fun h _ _ _ hm => (h hm).comm _⟩
-#align set.centralizer_eq_top_iff_subset Set.centralizer_eq_top_iff_subset
-#align set.add_centralizer_eq_top_iff_subset Set.addCentralizer_eq_top_iff_subset
-
-variable (M)
-
-@[to_additive (attr := simp) addCentralizer_univ]
-theorem centralizer_univ [Semigroup M] : centralizer univ = center M :=
-  Subset.antisymm (fun _ ha => Semigroup.mem_center_iff.mpr fun b => ha b (Set.mem_univ b))
-  fun _ ha b _ => (ha.comm b).symm
-#align set.centralizer_univ Set.centralizer_univ
-#align set.add_centralizer_univ Set.addCentralizer_univ
-
-variable {M} (S)
-
-@[to_additive (attr := simp) addCentralizer_eq_univ]
-theorem centralizer_eq_univ [CommSemigroup M] : centralizer S = univ :=
-  (Subset.antisymm (subset_univ _)) fun x _ y _ => mul_comm y x
-#align set.centralizer_eq_univ Set.centralizer_eq_univ
-#align set.add_centralizer_eq_univ Set.addCentralizer_eq_univ
-
-end Set
-
 namespace Subsemigroup
 
 section

chore: refactor to avoid importing Ring for Group topics (#11913)

This is a far from a complete success at the PR title, but it makes a fair bit of progress, and then guards this with appropriate assert_not_exists Ring statements.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

8e052acc

chore: refactor to avoid importing Ring for Group topics (#11913)

This is a far from a complete success at the PR title, but it makes a fair bit of progress, and then guards this with appropriate assert_not_exists Ring statements.

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

8e052acc

chore: Move GroupWithZero lemmas earlier (#10919)

Move from Algebra.GroupWithZero.Units.Lemmas to Algebra.GroupWithZero.Units.Basic the lemmas that can be moved.

8ff9aa61

Diff

@@ -4,7 +4,6 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
 -/
 import Mathlib.GroupTheory.Subsemigroup.Center
-import Mathlib.Algebra.GroupWithZero.Units.Lemmas
 
 #align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"

style: cleanup by putting by on the same line as := (#8407)

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

5e9b46ed

Diff

@@ -73,8 +73,8 @@ theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈
 #align set.add_mem_add_centralizer Set.add_mem_addCentralizer
 
 @[to_additive (attr := simp) neg_mem_addCentralizer]
-theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S := fun g hg =>
-  by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
+theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S :=
+  fun g hg => by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
 #align set.inv_mem_centralizer Set.inv_mem_centralizer
 #align set.neg_mem_add_centralizer Set.neg_mem_addCentralizer

refactor(Algebra): Define the center appropriately for non-associative algebras (#6996)

For a sensible theory, we require that the centre of an algebra is closed under multiplication. The definition currently in Mathlib works for associative algebras, but not non-associative algebras. This PR uses the definition from Cabrera García and Rodríguez Palacios, which works for any multiplication (addition) and which coincides with the current definition in the associative case.

I did consider whether the centralizer should also be re-defined in terms of operator commutation, but this still results in a centralizer which is not closed under multiplication in the non-associative case. I have therefore retained the current definition, but changed centralizer_eq_top_iff_subset and centralizer_univ to only work in the associative case.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Christopher Hoskin <mans0954@users.noreply.github.com> Co-authored-by: Christopher Hoskin <christopher.hoskin@overleaf.com>

2fed2bb8

Diff

@@ -121,22 +121,25 @@ theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer
 
 @[to_additive addCenter_subset_addCentralizer]
 theorem center_subset_centralizer [Mul M] (S : Set M) : Set.center M ⊆ S.centralizer :=
-  fun _ hx m _ => hx m
+  fun _ hx m _ => (hx.comm m).symm
 #align set.center_subset_centralizer Set.center_subset_centralizer
 #align set.add_center_subset_add_centralizer Set.addCenter_subset_addCentralizer
 
 @[to_additive (attr := simp) addCentralizer_eq_top_iff_subset]
-theorem centralizer_eq_top_iff_subset {s : Set M} [Mul M] :
+theorem centralizer_eq_top_iff_subset {s : Set M} [Semigroup M] :
     centralizer s = Set.univ ↔ s ⊆ center M :=
-  eq_top_iff.trans <| ⟨fun h _ hx _ => (h trivial _ hx).symm, fun h x _ _ hm => (h hm x).symm⟩
+  eq_top_iff.trans <| ⟨
+    fun h _ hx => Semigroup.mem_center_iff.mpr fun _ => by rw [h trivial _ hx],
+    fun h _ _ _ hm => (h hm).comm _⟩
 #align set.centralizer_eq_top_iff_subset Set.centralizer_eq_top_iff_subset
 #align set.add_centralizer_eq_top_iff_subset Set.addCentralizer_eq_top_iff_subset
 
 variable (M)
 
 @[to_additive (attr := simp) addCentralizer_univ]
-theorem centralizer_univ [Mul M] : centralizer univ = center M :=
-  Subset.antisymm (fun _ ha b => ha b (Set.mem_univ b)) fun _ ha b _ => ha b
+theorem centralizer_univ [Semigroup M] : centralizer univ = center M :=
+  Subset.antisymm (fun _ ha => Semigroup.mem_center_iff.mpr fun b => ha b (Set.mem_univ b))
+  fun _ ha b _ => (ha.comm b).symm
 #align set.centralizer_univ Set.centralizer_univ
 #align set.add_centralizer_univ Set.addCentralizer_univ

chore: banish Type _ and Sort _ (#6499)

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

32de3f67

Diff

@@ -23,7 +23,7 @@ We provide `Monoid.centralizer`, `AddMonoid.centralizer`, `Subgroup.centralizer`
 -/
 
 
-variable {M : Type _} {S T : Set M}
+variable {M : Type*} {S T : Set M}
 
 namespace Set

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

Co-authored-by: Eric Wieser <wieser.eric@gmail.com> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

89aa3a3b

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2021 Thomas Browning. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
-
-! This file was ported from Lean 3 source module group_theory.subsemigroup.centralizer
-! leanprover-community/mathlib commit cc67cd75b4e54191e13c2e8d722289a89e67e4fa
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.GroupTheory.Subsemigroup.Center
 import Mathlib.Algebra.GroupWithZero.Units.Lemmas
 
+#align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"
+
 /-!
 # Centralizers of magmas and semigroups

chore: fix addCentralizer naming (#4968)

This did not obey the naming convention; this is now fixed.

13af0fb7

Diff

@@ -41,13 +41,11 @@ def centralizer [Mul M] : Set M :=
 
 variable {S}
 
--- TODO: this additive naming in this section does not conform to the
--- naming convention. This will be fixed soon.
-@[to_additive mem_add_centralizer]
+@[to_additive mem_addCentralizer]
 theorem mem_centralizer_iff [Mul M] {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m :=
   Iff.rfl
 #align set.mem_centralizer_iff Set.mem_centralizer_iff
-#align set.mem_add_centralizer Set.mem_add_centralizer
+#align set.mem_add_centralizer Set.mem_addCentralizer
 
 @[to_additive decidableMemAddCentralizer]
 instance decidableMemCentralizer [Mul M] [∀ a : M, Decidable <| ∀ b ∈ S, b * a = a * b] :
@@ -57,11 +55,11 @@ instance decidableMemCentralizer [Mul M] [∀ a : M, Decidable <| ∀ b ∈ S, b
 
 variable (S)
 
-@[to_additive (attr := simp) zero_mem_add_centralizer]
+@[to_additive (attr := simp) zero_mem_addCentralizer]
 theorem one_mem_centralizer [MulOneClass M] : (1 : M) ∈ centralizer S := by
   simp [mem_centralizer_iff]
 #align set.one_mem_centralizer Set.one_mem_centralizer
-#align set.zero_mem_add_centralizer Set.zero_mem_add_centralizer
+#align set.zero_mem_add_centralizer Set.zero_mem_addCentralizer
 
 @[simp]
 theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
@@ -70,18 +68,18 @@ theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
 
 variable {S} {a b : M}
 
-@[to_additive (attr := simp) add_mem_add_centralizer]
+@[to_additive (attr := simp) add_mem_addCentralizer]
 theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a * b ∈ centralizer S := fun g hg => by
   rw [mul_assoc, ← hb g hg, ← mul_assoc, ha g hg, mul_assoc]
 #align set.mul_mem_centralizer Set.mul_mem_centralizer
-#align set.add_mem_add_centralizer Set.add_mem_add_centralizer
+#align set.add_mem_add_centralizer Set.add_mem_addCentralizer
 
-@[to_additive (attr := simp) neg_mem_add_centralizer]
+@[to_additive (attr := simp) neg_mem_addCentralizer]
 theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S := fun g hg =>
   by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
 #align set.inv_mem_centralizer Set.inv_mem_centralizer
-#align set.neg_mem_add_centralizer Set.neg_mem_add_centralizer
+#align set.neg_mem_add_centralizer Set.neg_mem_addCentralizer
 
 @[simp]
 theorem add_mem_centralizer [Distrib M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
@@ -103,13 +101,13 @@ theorem inv_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) : a
     rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
 #align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀
 
-@[to_additive (attr := simp) sub_mem_add_centralizer]
+@[to_additive (attr := simp) sub_mem_addCentralizer]
 theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a / b ∈ centralizer S := by
   rw [div_eq_mul_inv]
   exact mul_mem_centralizer ha (inv_mem_centralizer hb)
 #align set.div_mem_centralizer Set.div_mem_centralizer
-#align set.sub_mem_add_centralizer Set.sub_mem_add_centralizer
+#align set.sub_mem_add_centralizer Set.sub_mem_addCentralizer
 
 @[simp]
 theorem div_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
@@ -118,11 +116,11 @@ theorem div_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) (hb
   exact mul_mem_centralizer ha (inv_mem_centralizer₀ hb)
 #align set.div_mem_centralizer₀ Set.div_mem_centralizer₀
 
-@[to_additive add_centralizer_subset]
+@[to_additive addCentralizer_subset]
 theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer S := fun _ ht s hs =>
   ht s (h hs)
 #align set.centralizer_subset Set.centralizer_subset
-#align set.add_centralizer_subset Set.add_centralizer_subset
+#align set.add_centralizer_subset Set.addCentralizer_subset
 
 @[to_additive addCenter_subset_addCentralizer]
 theorem center_subset_centralizer [Mul M] (S : Set M) : Set.center M ⊆ S.centralizer :=
@@ -139,19 +137,19 @@ theorem centralizer_eq_top_iff_subset {s : Set M} [Mul M] :
 
 variable (M)
 
-@[to_additive (attr := simp) add_centralizer_univ]
+@[to_additive (attr := simp) addCentralizer_univ]
 theorem centralizer_univ [Mul M] : centralizer univ = center M :=
   Subset.antisymm (fun _ ha b => ha b (Set.mem_univ b)) fun _ ha b _ => ha b
 #align set.centralizer_univ Set.centralizer_univ
-#align set.add_centralizer_univ Set.add_centralizer_univ
+#align set.add_centralizer_univ Set.addCentralizer_univ
 
 variable {M} (S)
 
-@[to_additive (attr := simp) add_centralizer_eq_univ]
+@[to_additive (attr := simp) addCentralizer_eq_univ]
 theorem centralizer_eq_univ [CommSemigroup M] : centralizer S = univ :=
   (Subset.antisymm (subset_univ _)) fun x _ y _ => mul_comm y x
 #align set.centralizer_eq_univ Set.centralizer_eq_univ
-#align set.add_centralizer_eq_univ Set.add_centralizer_eq_univ
+#align set.add_centralizer_eq_univ Set.addCentralizer_eq_univ
 
 end Set

chore: port leanprover-community/mathlib#18861 (#4896)

I forgot to put some required to_additives in Lean3, I am currently backporting this change in leanprover-community/mathlib#19168.

Co-authored-by: Eric Rodriguez <37984851+ericrbg@users.noreply.github.com>

b0a21674

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Thomas Browning, Jireh Loreaux
 
 ! This file was ported from Lean 3 source module group_theory.subsemigroup.centralizer
-! leanprover-community/mathlib commit ffc3730d545623aedf5d5bd46a3153cbf41f6c2c
+! leanprover-community/mathlib commit cc67cd75b4e54191e13c2e8d722289a89e67e4fa
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -41,6 +41,8 @@ def centralizer [Mul M] : Set M :=
 
 variable {S}
 
+-- TODO: this additive naming in this section does not conform to the
+-- naming convention. This will be fixed soon.
 @[to_additive mem_add_centralizer]
 theorem mem_centralizer_iff [Mul M] {c : M} : c ∈ centralizer S ↔ ∀ m ∈ S, m * c = c * m :=
   Iff.rfl
@@ -122,6 +124,19 @@ theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer
 #align set.centralizer_subset Set.centralizer_subset
 #align set.add_centralizer_subset Set.add_centralizer_subset
 
+@[to_additive addCenter_subset_addCentralizer]
+theorem center_subset_centralizer [Mul M] (S : Set M) : Set.center M ⊆ S.centralizer :=
+  fun _ hx m _ => hx m
+#align set.center_subset_centralizer Set.center_subset_centralizer
+#align set.add_center_subset_add_centralizer Set.addCenter_subset_addCentralizer
+
+@[to_additive (attr := simp) addCentralizer_eq_top_iff_subset]
+theorem centralizer_eq_top_iff_subset {s : Set M} [Mul M] :
+    centralizer s = Set.univ ↔ s ⊆ center M :=
+  eq_top_iff.trans <| ⟨fun h _ hx _ => (h trivial _ hx).symm, fun h x _ _ hm => (h hm x).symm⟩
+#align set.centralizer_eq_top_iff_subset Set.centralizer_eq_top_iff_subset
+#align set.add_centralizer_eq_top_iff_subset Set.addCentralizer_eq_top_iff_subset
+
 variable (M)
 
 @[to_additive (attr := simp) add_centralizer_univ]
@@ -175,12 +190,24 @@ instance decidableMemCentralizer (a) [Decidable <| ∀ b ∈ S, b * a = a * b] :
 #align subsemigroup.decidable_mem_centralizer Subsemigroup.decidableMemCentralizer
 #align add_subsemigroup.decidable_mem_centralizer AddSubsemigroup.decidableMemCentralizer
 
+@[to_additive]
+theorem center_le_centralizer (S) : center M ≤ centralizer S :=
+  S.center_subset_centralizer
+#align subsemigroup.center_le_centralizer Subsemigroup.center_le_centralizer
+#align add_subsemigroup.center_le_centralizer AddSubsemigroup.center_le_centralizer
+
 @[to_additive]
 theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
   Set.centralizer_subset h
 #align subsemigroup.centralizer_le Subsemigroup.centralizer_le
 #align add_subsemigroup.centralizer_le AddSubsemigroup.centralizer_le
 
+@[to_additive (attr := simp)]
+theorem centralizer_eq_top_iff_subset {s : Set M} : centralizer s = ⊤ ↔ s ⊆ center M :=
+  SetLike.ext'_iff.trans Set.centralizer_eq_top_iff_subset
+#align subsemigroup.centralizer_eq_top_iff_subset Subsemigroup.centralizer_eq_top_iff_subset
+#align add_subsemigroup.centralizer_eq_top_iff_subset AddSubsemigroup.centralizer_eq_top_iff_subset
+
 variable (M)
 @[to_additive (attr := simp)]
 theorem centralizer_univ : centralizer Set.univ = center M :=

feat: assert_not_exists (#4245)

25809c65

Diff

@@ -192,6 +192,5 @@ end
 
 end Subsemigroup
 
--- porting note: This does not exist yet, however it is not relevant for functionality
 -- Guard against import creep
--- assert_not_exists finset
+assert_not_exists Finset

feat: improve the way to_additive deals with attributes (#1314)

The new syntax for any attributes that need to be copied by to_additive is @[to_additive (attrs := simp, ext, simps)]
Adds the auxiliary declarations generated by the simp and simps attributes to the to_additive-dictionary.
Future issue: Does not yet translate auxiliary declarations for other attributes (including custom simp-attributes). In particular it's possible that norm_cast might generate some auxiliary declarations.
Fixes #950
Fixes #953
Fixes #1149
This moves the interaction between to_additive and simps from the Simps file to the toAdditive file for uniformity.
Make the same changes to @[reassoc]

Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

56bf4cd6

Diff

@@ -55,7 +55,7 @@ instance decidableMemCentralizer [Mul M] [∀ a : M, Decidable <| ∀ b ∈ S, b
 
 variable (S)
 
-@[simp, to_additive zero_mem_add_centralizer]
+@[to_additive (attr := simp) zero_mem_add_centralizer]
 theorem one_mem_centralizer [MulOneClass M] : (1 : M) ∈ centralizer S := by
   simp [mem_centralizer_iff]
 #align set.one_mem_centralizer Set.one_mem_centralizer
@@ -68,14 +68,14 @@ theorem zero_mem_centralizer [MulZeroClass M] : (0 : M) ∈ centralizer S := by
 
 variable {S} {a b : M}
 
-@[simp, to_additive add_mem_add_centralizer]
+@[to_additive (attr := simp) add_mem_add_centralizer]
 theorem mul_mem_centralizer [Semigroup M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a * b ∈ centralizer S := fun g hg => by
   rw [mul_assoc, ← hb g hg, ← mul_assoc, ha g hg, mul_assoc]
 #align set.mul_mem_centralizer Set.mul_mem_centralizer
 #align set.add_mem_add_centralizer Set.add_mem_add_centralizer
 
-@[simp, to_additive neg_mem_add_centralizer]
+@[to_additive (attr := simp) neg_mem_add_centralizer]
 theorem inv_mem_centralizer [Group M] (ha : a ∈ centralizer S) : a⁻¹ ∈ centralizer S := fun g hg =>
   by rw [mul_inv_eq_iff_eq_mul, mul_assoc, eq_inv_mul_iff_mul_eq, ha g hg]
 #align set.inv_mem_centralizer Set.inv_mem_centralizer
@@ -101,7 +101,7 @@ theorem inv_mem_centralizer₀ [GroupWithZero M] (ha : a ∈ centralizer S) : a
     rw [mul_inv_eq_iff_eq_mul₀ ha0, mul_assoc, eq_inv_mul_iff_mul_eq₀ ha0, ha c hc]
 #align set.inv_mem_centralizer₀ Set.inv_mem_centralizer₀
 
-@[simp, to_additive sub_mem_add_centralizer]
+@[to_additive (attr := simp) sub_mem_add_centralizer]
 theorem div_mem_centralizer [Group M] (ha : a ∈ centralizer S) (hb : b ∈ centralizer S) :
     a / b ∈ centralizer S := by
   rw [div_eq_mul_inv]
@@ -124,7 +124,7 @@ theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer
 
 variable (M)
 
-@[simp, to_additive add_centralizer_univ]
+@[to_additive (attr := simp) add_centralizer_univ]
 theorem centralizer_univ [Mul M] : centralizer univ = center M :=
   Subset.antisymm (fun _ ha b => ha b (Set.mem_univ b)) fun _ ha b _ => ha b
 #align set.centralizer_univ Set.centralizer_univ
@@ -132,7 +132,7 @@ theorem centralizer_univ [Mul M] : centralizer univ = center M :=
 
 variable {M} (S)
 
-@[simp, to_additive add_centralizer_eq_univ]
+@[to_additive (attr := simp) add_centralizer_eq_univ]
 theorem centralizer_eq_univ [CommSemigroup M] : centralizer S = univ :=
   (Subset.antisymm (subset_univ _)) fun x _ y _ => mul_comm y x
 #align set.centralizer_eq_univ Set.centralizer_eq_univ
@@ -154,7 +154,7 @@ def centralizer : Subsemigroup M where
 #align subsemigroup.centralizer Subsemigroup.centralizer
 #align add_subsemigroup.centralizer AddSubsemigroup.centralizer
 
-@[simp, norm_cast, to_additive]
+@[to_additive (attr := simp, norm_cast)]
 theorem coe_centralizer : ↑(centralizer S) = S.centralizer :=
   rfl
 #align subsemigroup.coe_centralizer Subsemigroup.coe_centralizer
@@ -182,7 +182,7 @@ theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
 #align add_subsemigroup.centralizer_le AddSubsemigroup.centralizer_le
 
 variable (M)
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem centralizer_univ : centralizer Set.univ = center M :=
   SetLike.ext' (Set.centralizer_univ M)
 #align subsemigroup.centralizer_univ Subsemigroup.centralizer_univ

feat: port GroupTheory.Submonoid.Center (#1315)

Also includes fixes in other files as well (Set.Center to Set.center and a few more like that).

f6c80f83

Diff

@@ -125,7 +125,7 @@ theorem centralizer_subset [Mul M] (h : S ⊆ T) : centralizer T ⊆ centralizer
 variable (M)
 
 @[simp, to_additive add_centralizer_univ]
-theorem centralizer_univ [Mul M] : centralizer univ = Center M :=
+theorem centralizer_univ [Mul M] : centralizer univ = center M :=
   Subset.antisymm (fun _ ha b => ha b (Set.mem_univ b)) fun _ ha b _ => ha b
 #align set.centralizer_univ Set.centralizer_univ
 #align set.add_centralizer_univ Set.add_centralizer_univ
@@ -183,7 +183,7 @@ theorem centralizer_le (h : S ⊆ T) : centralizer T ≤ centralizer S :=
 
 variable (M)
 @[simp, to_additive]
-theorem centralizer_univ : centralizer Set.univ = Center M :=
+theorem centralizer_univ : centralizer Set.univ = center M :=
   SetLike.ext' (Set.centralizer_univ M)
 #align subsemigroup.centralizer_univ Subsemigroup.centralizer_univ
 #align add_subsemigroup.centralizer_univ AddSubsemigroup.centralizer_univ
@@ -195,4 +195,3 @@ end Subsemigroup
 -- porting note: This does not exist yet, however it is not relevant for functionality
 -- Guard against import creep
 -- assert_not_exists finset
-