group_theory.subgroup.zpowers | Mathlib porting status

(last sync)

fix(group_theory/subgroup/basic): generalize centralizer from subgroup G to set G (#18965)

This is consistent with all the other sub<foo>.centralizer definitions.

This generalization reveals that a lot of downstream results are rather strangely stated about zpowers. This does not attempt to change these, instead leaving the work for a follow up (either in a later mathlib3 PR or in mathlib4).

Diff

@@ -166,17 +166,19 @@ zpowers_eq_bot.not
 subgroup.zpowers_eq_bot.mpr rfl
 
 @[to_additive] lemma centralizer_closure (S : set G) :
-  (closure S).centralizer = ⨅ g ∈ S, (zpowers g).centralizer :=
-le_antisymm (le_infi $ λ g, le_infi $ λ hg, centralizer_le $ zpowers_le.2 $ subset_closure hg)
+  centralizer (closure S : set G) = ⨅ g ∈ S, centralizer (zpowers g : set G) :=
+le_antisymm
+  (le_infi $ λ g, le_infi $ λ hg, centralizer_le $ set_like.coe_subset_coe.2 $
+    zpowers_le.2 $ subset_closure hg)
   $ le_centralizer_iff.1 $ (closure_le _).2
   $ λ g, set_like.mem_coe.2 ∘ zpowers_le.1 ∘ le_centralizer_iff.1 ∘ infi_le_of_le g ∘ infi_le _
 
 @[to_additive] lemma center_eq_infi (S : set G) (hS : closure S = ⊤) :
   center G = ⨅ g ∈ S, centralizer (zpowers g) :=
-by rw [←centralizer_top, ←hS, centralizer_closure]
+by rw [←centralizer_univ, ←coe_top, ←hS, centralizer_closure]
 
 @[to_additive] lemma center_eq_infi' (S : set G) (hS : closure S = ⊤) :
-  center G = ⨅ g : S, centralizer (zpowers g) :=
+  center G = ⨅ g : S, centralizer (zpowers (g : G) : set G) :=
 by rw [center_eq_infi S hS, ←infi_subtype'']
 
 end subgroup

feat(algebra/group_power/lemmas): Induction principle for powers (#18668)

A property holds for all powers of g if it is holds for 1 and is preserved under multiplication and division by g.

Also rename subgroup.zpowers_subset/add_subgroup.zmultiples_subset to subgroup.zpowers_le_of_mem/add_subgroup.zmultiples_le_of_mem because there is no ⊆ in the statement.

The motivation is the Cauchy-Davenport theorem: https://github.com/leanprover-community/mathlib/blob/321b67021163ac504c6cfa35d5678a47b357869d/src/combinatorics/additive/cauchy_davenport.lean#L176-L181

Diff

@@ -29,14 +29,13 @@ subgroup.copy (zpowers_hom G g).range (set.range ((^) g : ℤ → G)) rfl
 
 @[simp] lemma mem_zpowers (g : G) : g ∈ zpowers g := ⟨1, zpow_one _⟩
 
+@[norm_cast] lemma coe_zpowers (g : G) : ↑(zpowers g) = set.range (λ n : ℤ, g ^ n) := rfl
+
 lemma zpowers_eq_closure (g : G) : zpowers g = closure {g} :=
 by { ext, exact mem_closure_singleton.symm }
 
 @[simp] lemma range_zpowers_hom (g : G) : (zpowers_hom G g).range = zpowers g := rfl
 
-lemma zpowers_subset {a : G} {K : subgroup G} (h : a ∈ K) : zpowers a ≤ K :=
-λ x hx, match x, hx with _, ⟨i, rfl⟩ := K.zpow_mem h i end
-
 lemma mem_zpowers_iff {g h : G} :
   h ∈ zpowers g ↔ ∃ (k : ℤ), g ^ k = h :=
 iff.rfl
@@ -78,9 +77,9 @@ add_subgroup.copy (zmultiples_hom A a).range (set.range ((• a) : ℤ → A)) r
 
 attribute [to_additive add_subgroup.zmultiples] subgroup.zpowers
 attribute [to_additive add_subgroup.mem_zmultiples] subgroup.mem_zpowers
+attribute [to_additive add_subgroup.coe_zmultiples] subgroup.coe_zpowers
 attribute [to_additive add_subgroup.zmultiples_eq_closure] subgroup.zpowers_eq_closure
 attribute [to_additive add_subgroup.range_zmultiples_hom] subgroup.range_zpowers_hom
-attribute [to_additive add_subgroup.zmultiples_subset] subgroup.zpowers_subset
 attribute [to_additive add_subgroup.mem_zmultiples_iff] subgroup.mem_zpowers_iff
 attribute [to_additive add_subgroup.zsmul_mem_zmultiples] subgroup.zpow_mem_zpowers
 attribute [to_additive add_subgroup.nsmul_mem_zmultiples] subgroup.npow_mem_zpowers
@@ -140,6 +139,7 @@ begin
 end
 
 namespace subgroup
+variables {s : set G} {g : G}
 
 @[to_additive zmultiples_is_commutative]
 instance zpowers_is_commutative (g : G) : (zpowers g).is_commutative :=
@@ -150,9 +150,17 @@ instance zpowers_is_commutative (g : G) : (zpowers g).is_commutative :=
 lemma zpowers_le {g : G} {H : subgroup G} : zpowers g ≤ H ↔ g ∈ H :=
 by rw [zpowers_eq_closure, closure_le, set.singleton_subset_iff, set_like.mem_coe]
 
+alias zpowers_le ↔ _ zpowers_le_of_mem
+alias add_subgroup.zmultiples_le ↔ _ _root_.add_subgroup.zmultiples_le_of_mem
+
+attribute [to_additive zmultiples_le_of_mem] zpowers_le_of_mem
+
 @[simp, to_additive zmultiples_eq_bot] lemma zpowers_eq_bot {g : G} : zpowers g = ⊥ ↔ g = 1 :=
 by rw [eq_bot_iff, zpowers_le, mem_bot]
 
+@[to_additive zmultiples_ne_bot] lemma zpowers_ne_bot : zpowers g ≠ ⊥ ↔ g ≠ 1 :=
+zpowers_eq_bot.not
+
 @[simp, to_additive zmultiples_zero_eq_bot] lemma zpowers_one_eq_bot :
    subgroup.zpowers (1 : G) = ⊥ :=
 subgroup.zpowers_eq_bot.mpr rfl

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-19-08

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

a9e81450

Diff

@@ -159,18 +159,18 @@ section Ring
 
 variable {R : Type _} [Ring R] (r : R) (k : ℤ)
 
-#print AddSubgroup.int_cast_mul_mem_zmultiples /-
+#print AddSubgroup.intCast_mul_mem_zmultiples /-
 @[simp]
-theorem int_cast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
+theorem intCast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
   simpa only [← zsmul_eq_mul] using zsmul_mem_zmultiples r k
-#align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.int_cast_mul_mem_zmultiples
+#align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.intCast_mul_mem_zmultiples
 -/
 
-#print AddSubgroup.int_cast_mem_zmultiples_one /-
+#print AddSubgroup.intCast_mem_zmultiples_one /-
 @[simp]
-theorem int_cast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R) :=
+theorem intCast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R) :=
   mem_zmultiples_iff.mp ⟨k, by simp⟩
-#align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.int_cast_mem_zmultiples_one
+#align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.intCast_mem_zmultiples_one
 -/
 
 end Ring

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -77,7 +77,7 @@ theorem zpow_mem_zpowers (g : G) (k : ℤ) : g ^ k ∈ zpowers g :=
 #print Subgroup.npow_mem_zpowers /-
 @[simp]
 theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
-  zpow_coe_nat g k ▸ zpow_mem_zpowers g k
+  zpow_natCast g k ▸ zpow_mem_zpowers g k
 #align subgroup.npow_mem_zpowers Subgroup.npow_mem_zpowers
 -/

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -97,7 +97,7 @@ theorem exists_zpowers {x : G} {p : zpowers x → Prop} : (∃ g, p g) ↔ ∃ m
 
 #print Subgroup.forall_mem_zpowers /-
 theorem forall_mem_zpowers {x : G} {p : G → Prop} : (∀ g ∈ zpowers x, p g) ↔ ∀ m : ℤ, p (x ^ m) :=
-  Set.forall_range_iff
+  Set.forall_mem_range
 #align subgroup.forall_mem_zpowers Subgroup.forall_mem_zpowers
 -/

bump to nightly-2024-02-29-08

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

74acbaea

Diff

@@ -77,7 +77,7 @@ theorem zpow_mem_zpowers (g : G) (k : ℤ) : g ^ k ∈ zpowers g :=
 #print Subgroup.npow_mem_zpowers /-
 @[simp]
 theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
-  zpow_ofNat g k ▸ zpow_mem_zpowers g k
+  zpow_coe_nat g k ▸ zpow_mem_zpowers g k
 #align subgroup.npow_mem_zpowers Subgroup.npow_mem_zpowers
 -/

bump to nightly-2024-02-23-08

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

ac9421d6

Diff

@@ -225,7 +225,7 @@ variable {s : Set G} {g : G}
 
 #print Subgroup.zpowers_isCommutative /-
 @[to_additive zmultiples_is_commutative]
-instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutativeₓ :=
+instance zpowers_isCommutative (g : G) : (zpowers g).Commutative :=
   ⟨⟨fun ⟨_, _, h₁⟩ ⟨_, _, h₂⟩ => by
       rw [Subtype.ext_iff, coe_mul, coe_mul, Subtype.coe_mk, Subtype.coe_mk, ← h₁, ← h₂,
         zpow_mul_comm]⟩⟩

bump to nightly-2024-02-05-08

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

516c6ec2

Diff

@@ -225,7 +225,7 @@ variable {s : Set G} {g : G}
 
 #print Subgroup.zpowers_isCommutative /-
 @[to_additive zmultiples_is_commutative]
-instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
+instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutativeₓ :=
   ⟨⟨fun ⟨_, _, h₁⟩ ⟨_, _, h₂⟩ => by
       rw [Subtype.ext_iff, coe_mul, coe_mul, Subtype.coe_mk, Subtype.coe_mk, ← h₁, ← h₂,
         zpow_mul_comm]⟩⟩

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Mathbin.GroupTheory.Subgroup.Basic
+import GroupTheory.Subgroup.Basic
 
 #align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -241,10 +241,10 @@ theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
 #align add_subgroup.zmultiples_le AddSubgroup.zmultiples_le
 -/
 
-alias zpowers_le ↔ _ zpowers_le_of_mem
+alias ⟨_, zpowers_le_of_mem⟩ := zpowers_le
 #align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_mem
 
-alias AddSubgroup.zmultiples_le ↔ _ _root_.add_subgroup.zmultiples_le_of_mem
+alias ⟨_, _root_.add_subgroup.zmultiples_le_of_mem⟩ := AddSubgroup.zmultiples_le
 #align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_mem
 
 attribute [to_additive zmultiples_le_of_mem] zpowers_le_of_mem

bump to nightly-2023-07-25-03

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

748c9a7c

Diff

@@ -5,7 +5,7 @@ Authors: Chris Hughes
 -/
 import Mathbin.GroupTheory.Subgroup.Basic
 
-#align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
+#align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
 
 /-!
 # Subgroups generated by an element
@@ -275,9 +275,11 @@ theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
 #print Subgroup.centralizer_closure /-
 @[to_additive]
 theorem centralizer_closure (S : Set G) :
-    (closure S).centralizer = ⨅ g ∈ S, (zpowers g).centralizer :=
+    centralizer (closure S : Set G) = ⨅ g ∈ S, centralizer (zpowers g : Set G) :=
   le_antisymm
-      (le_iInf fun g => le_iInf fun hg => centralizer_le <| zpowers_le.2 <| subset_closure hg) <|
+      (le_iInf fun g =>
+        le_iInf fun hg =>
+          centralizer_le <| SetLike.coe_subset_coe.2 <| zpowers_le.2 <| subset_closure hg) <|
     le_centralizer_iff.1 <|
       (closure_le _).2 fun g =>
         SetLike.mem_coe.2 ∘ zpowers_le.1 ∘ le_centralizer_iff.1 ∘ iInf_le_of_le g ∘ iInf_le _
@@ -289,7 +291,7 @@ theorem centralizer_closure (S : Set G) :
 @[to_additive]
 theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g ∈ S, centralizer (zpowers g) := by
-  rw [← centralizer_top, ← hS, centralizer_closure]
+  rw [← centralizer_univ, ← coe_top, ← hS, centralizer_closure]
 #align subgroup.center_eq_infi Subgroup.center_eq_iInf
 #align add_subgroup.center_eq_infi AddSubgroup.center_eq_iInf
 -/
@@ -297,7 +299,8 @@ theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
 #print Subgroup.center_eq_infi' /-
 @[to_additive]
 theorem center_eq_infi' (S : Set G) (hS : closure S = ⊤) :
-    center G = ⨅ g : S, centralizer (zpowers g) := by rw [center_eq_infi S hS, ← iInf_subtype'']
+    center G = ⨅ g : S, centralizer (zpowers (g : G) : Set G) := by
+  rw [center_eq_infi S hS, ← iInf_subtype'']
 #align subgroup.center_eq_infi' Subgroup.center_eq_infi'
 #align add_subgroup.center_eq_infi' AddSubgroup.center_eq_infi'
 -/

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module group_theory.subgroup.zpowers
-! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.GroupTheory.Subgroup.Basic
 
+#align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
+
 /-!
 # Subgroups generated by an element

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -37,15 +37,19 @@ def zpowers (g : G) : Subgroup G :=
 #align subgroup.zpowers Subgroup.zpowers
 -/
 
+#print Subgroup.mem_zpowers /-
 @[simp]
 theorem mem_zpowers (g : G) : g ∈ zpowers g :=
   ⟨1, zpow_one _⟩
 #align subgroup.mem_zpowers Subgroup.mem_zpowers
+-/
 
+#print Subgroup.coe_zpowers /-
 @[norm_cast]
 theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range fun n : ℤ => g ^ n :=
   rfl
 #align subgroup.coe_zpowers Subgroup.coe_zpowers
+-/
 
 #print Subgroup.zpowers_eq_closure /-
 theorem zpowers_eq_closure (g : G) : zpowers g = closure {g} := by ext;
@@ -60,37 +64,51 @@ theorem range_zpowersHom (g : G) : (zpowersHom G g).range = zpowers g :=
 #align subgroup.range_zpowers_hom Subgroup.range_zpowersHom
 -/
 
+#print Subgroup.mem_zpowers_iff /-
 theorem mem_zpowers_iff {g h : G} : h ∈ zpowers g ↔ ∃ k : ℤ, g ^ k = h :=
   Iff.rfl
 #align subgroup.mem_zpowers_iff Subgroup.mem_zpowers_iff
+-/
 
+#print Subgroup.zpow_mem_zpowers /-
 @[simp]
 theorem zpow_mem_zpowers (g : G) (k : ℤ) : g ^ k ∈ zpowers g :=
   mem_zpowers_iff.mpr ⟨k, rfl⟩
 #align subgroup.zpow_mem_zpowers Subgroup.zpow_mem_zpowers
+-/
 
+#print Subgroup.npow_mem_zpowers /-
 @[simp]
 theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
   zpow_ofNat g k ▸ zpow_mem_zpowers g k
 #align subgroup.npow_mem_zpowers Subgroup.npow_mem_zpowers
+-/
 
+#print Subgroup.forall_zpowers /-
 @[simp]
 theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=
   Set.forall_subtype_range_iff
 #align subgroup.forall_zpowers Subgroup.forall_zpowers
+-/
 
+#print Subgroup.exists_zpowers /-
 @[simp]
 theorem exists_zpowers {x : G} {p : zpowers x → Prop} : (∃ g, p g) ↔ ∃ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=
   Set.exists_subtype_range_iff
 #align subgroup.exists_zpowers Subgroup.exists_zpowers
+-/
 
+#print Subgroup.forall_mem_zpowers /-
 theorem forall_mem_zpowers {x : G} {p : G → Prop} : (∀ g ∈ zpowers x, p g) ↔ ∀ m : ℤ, p (x ^ m) :=
   Set.forall_range_iff
 #align subgroup.forall_mem_zpowers Subgroup.forall_mem_zpowers
+-/
 
+#print Subgroup.exists_mem_zpowers /-
 theorem exists_mem_zpowers {x : G} {p : G → Prop} : (∃ g ∈ zpowers x, p g) ↔ ∃ m : ℤ, p (x ^ m) :=
   Set.exists_range_iff
 #align subgroup.exists_mem_zpowers Subgroup.exists_mem_zpowers
+-/
 
 instance (a : G) : Countable (zpowers a) :=
   ((zpowersHom G a).rangeRestrict_surjective.comp Multiplicative.ofAdd.Surjective).Countable
@@ -144,31 +162,40 @@ section Ring
 
 variable {R : Type _} [Ring R] (r : R) (k : ℤ)
 
+#print AddSubgroup.int_cast_mul_mem_zmultiples /-
 @[simp]
 theorem int_cast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
   simpa only [← zsmul_eq_mul] using zsmul_mem_zmultiples r k
 #align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.int_cast_mul_mem_zmultiples
+-/
 
+#print AddSubgroup.int_cast_mem_zmultiples_one /-
 @[simp]
 theorem int_cast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R) :=
   mem_zmultiples_iff.mp ⟨k, by simp⟩
 #align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.int_cast_mem_zmultiples_one
+-/
 
 end Ring
 
 end AddSubgroup
 
+#print MonoidHom.map_zpowers /-
 @[simp, to_additive map_zmultiples]
 theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
     (Subgroup.zpowers x).map f = Subgroup.zpowers (f x) := by
   rw [Subgroup.zpowers_eq_closure, Subgroup.zpowers_eq_closure, f.map_closure, Set.image_singleton]
 #align monoid_hom.map_zpowers MonoidHom.map_zpowers
 #align add_monoid_hom.map_zmultiples AddMonoidHom.map_zmultiples
+-/
 
+#print Int.mem_zmultiples_iff /-
 theorem Int.mem_zmultiples_iff {a b : ℤ} : b ∈ AddSubgroup.zmultiples a ↔ a ∣ b :=
   exists_congr fun k => by rw [mul_comm, eq_comm, ← smul_eq_mul]
 #align int.mem_zmultiples_iff Int.mem_zmultiples_iff
+-/
 
+#print ofMul_image_zpowers_eq_zmultiples_ofMul /-
 theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
     Additive.ofMul '' (Subgroup.zpowers x : Set G) = AddSubgroup.zmultiples (Additive.ofMul x) :=
   by
@@ -182,7 +209,9 @@ theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
     refine' ⟨x ^ n, ⟨n, rfl⟩, _⟩
     rwa [ofMul_zpow]
 #align of_mul_image_zpowers_eq_zmultiples_of_mul ofMul_image_zpowers_eq_zmultiples_ofMul
+-/
 
+#print ofAdd_image_zmultiples_eq_zpowers_ofAdd /-
 theorem ofAdd_image_zmultiples_eq_zpowers_ofAdd {x : A} :
     Multiplicative.ofAdd '' (AddSubgroup.zmultiples x : Set A) =
       Subgroup.zpowers (Multiplicative.ofAdd x) :=
@@ -191,6 +220,7 @@ theorem ofAdd_image_zmultiples_eq_zpowers_ofAdd {x : A} :
   rw [Equiv.eq_image_iff_symm_image_eq]
   exact ofMul_image_zpowers_eq_zmultiples_ofMul
 #align of_add_image_zmultiples_eq_zpowers_of_add ofAdd_image_zmultiples_eq_zpowers_ofAdd
+-/
 
 namespace Subgroup
 
@@ -206,11 +236,13 @@ instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
 #align add_subgroup.zmultiples_is_commutative AddSubgroup.zmultiples_isCommutative
 -/
 
+#print Subgroup.zpowers_le /-
 @[simp, to_additive zmultiples_le]
 theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
   rw [zpowers_eq_closure, closure_le, Set.singleton_subset_iff, SetLike.mem_coe]
 #align subgroup.zpowers_le Subgroup.zpowers_le
 #align add_subgroup.zmultiples_le AddSubgroup.zmultiples_le
+-/
 
 alias zpowers_le ↔ _ zpowers_le_of_mem
 #align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_mem
@@ -220,22 +252,28 @@ alias AddSubgroup.zmultiples_le ↔ _ _root_.add_subgroup.zmultiples_le_of_mem
 
 attribute [to_additive zmultiples_le_of_mem] zpowers_le_of_mem
 
+#print Subgroup.zpowers_eq_bot /-
 @[simp, to_additive zmultiples_eq_bot]
 theorem zpowers_eq_bot {g : G} : zpowers g = ⊥ ↔ g = 1 := by rw [eq_bot_iff, zpowers_le, mem_bot]
 #align subgroup.zpowers_eq_bot Subgroup.zpowers_eq_bot
 #align add_subgroup.zmultiples_eq_bot AddSubgroup.zmultiples_eq_bot
+-/
 
+#print Subgroup.zpowers_ne_bot /-
 @[to_additive zmultiples_ne_bot]
 theorem zpowers_ne_bot : zpowers g ≠ ⊥ ↔ g ≠ 1 :=
   zpowers_eq_bot.Not
 #align subgroup.zpowers_ne_bot Subgroup.zpowers_ne_bot
 #align add_subgroup.zmultiples_ne_bot AddSubgroup.zmultiples_ne_bot
+-/
 
+#print Subgroup.zpowers_one_eq_bot /-
 @[simp, to_additive zmultiples_zero_eq_bot]
 theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
   Subgroup.zpowers_eq_bot.mpr rfl
 #align subgroup.zpowers_one_eq_bot Subgroup.zpowers_one_eq_bot
 #align add_subgroup.zmultiples_zero_eq_bot AddSubgroup.zmultiples_zero_eq_bot
+-/
 
 #print Subgroup.centralizer_closure /-
 @[to_additive]
@@ -250,18 +288,22 @@ theorem centralizer_closure (S : Set G) :
 #align add_subgroup.centralizer_closure AddSubgroup.centralizer_closure
 -/
 
+#print Subgroup.center_eq_iInf /-
 @[to_additive]
 theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g ∈ S, centralizer (zpowers g) := by
   rw [← centralizer_top, ← hS, centralizer_closure]
 #align subgroup.center_eq_infi Subgroup.center_eq_iInf
 #align add_subgroup.center_eq_infi AddSubgroup.center_eq_iInf
+-/
 
+#print Subgroup.center_eq_infi' /-
 @[to_additive]
 theorem center_eq_infi' (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g : S, centralizer (zpowers g) := by rw [center_eq_infi S hS, ← iInf_subtype'']
 #align subgroup.center_eq_infi' Subgroup.center_eq_infi'
 #align add_subgroup.center_eq_infi' AddSubgroup.center_eq_infi'
+-/
 
 end Subgroup

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -37,23 +37,11 @@ def zpowers (g : G) : Subgroup G :=
 #align subgroup.zpowers Subgroup.zpowers
 -/
 
-/- warning: subgroup.mem_zpowers -> Subgroup.mem_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g (Subgroup.zpowers.{u1} G _inst_1 g)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g (Subgroup.zpowers.{u1} G _inst_1 g)
-Case conversion may be inaccurate. Consider using '#align subgroup.mem_zpowers Subgroup.mem_zpowersₓ'. -/
 @[simp]
 theorem mem_zpowers (g : G) : g ∈ zpowers g :=
   ⟨1, zpow_one _⟩
 #align subgroup.mem_zpowers Subgroup.mem_zpowers
 
-/- warning: subgroup.coe_zpowers -> Subgroup.coe_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} (Set.{u1} G) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} G _inst_1) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g)) (Set.range.{u1, 1} G Int (fun (n : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g n))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} (Set.{u1} G) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g)) (Set.range.{u1, 1} G Int (fun (n : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g n))
-Case conversion may be inaccurate. Consider using '#align subgroup.coe_zpowers Subgroup.coe_zpowersₓ'. -/
 @[norm_cast]
 theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range fun n : ℤ => g ^ n :=
   rfl
@@ -72,76 +60,34 @@ theorem range_zpowersHom (g : G) : (zpowersHom G g).range = zpowers g :=
 #align subgroup.range_zpowers_hom Subgroup.range_zpowersHom
 -/
 
-/- warning: subgroup.mem_zpowers_iff -> Subgroup.mem_zpowers_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {h : G}, Iff (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) h (Subgroup.zpowers.{u1} G _inst_1 g)) (Exists.{1} Int (fun (k : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g k) h))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {h : G}, Iff (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) h (Subgroup.zpowers.{u1} G _inst_1 g)) (Exists.{1} Int (fun (k : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g k) h))
-Case conversion may be inaccurate. Consider using '#align subgroup.mem_zpowers_iff Subgroup.mem_zpowers_iffₓ'. -/
 theorem mem_zpowers_iff {g h : G} : h ∈ zpowers g ↔ ∃ k : ℤ, g ^ k = h :=
   Iff.rfl
 #align subgroup.mem_zpowers_iff Subgroup.mem_zpowers_iff
 
-/- warning: subgroup.zpow_mem_zpowers -> Subgroup.zpow_mem_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G) (k : Int), Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g k) (Subgroup.zpowers.{u1} G _inst_1 g)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G) (k : Int), Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g k) (Subgroup.zpowers.{u1} G _inst_1 g)
-Case conversion may be inaccurate. Consider using '#align subgroup.zpow_mem_zpowers Subgroup.zpow_mem_zpowersₓ'. -/
 @[simp]
 theorem zpow_mem_zpowers (g : G) (k : ℤ) : g ^ k ∈ zpowers g :=
   mem_zpowers_iff.mpr ⟨k, rfl⟩
 #align subgroup.zpow_mem_zpowers Subgroup.zpow_mem_zpowers
 
-/- warning: subgroup.npow_mem_zpowers -> Subgroup.npow_mem_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G) (k : Nat), Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (HPow.hPow.{u1, 0, u1} G Nat G (instHPow.{u1, 0} G Nat (Monoid.Pow.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) g k) (Subgroup.zpowers.{u1} G _inst_1 g)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G) (k : Nat), Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) (HPow.hPow.{u1, 0, u1} G Nat G (instHPow.{u1, 0} G Nat (Monoid.Pow.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) g k) (Subgroup.zpowers.{u1} G _inst_1 g)
-Case conversion may be inaccurate. Consider using '#align subgroup.npow_mem_zpowers Subgroup.npow_mem_zpowersₓ'. -/
 @[simp]
 theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
   zpow_ofNat g k ▸ zpow_mem_zpowers g k
 #align subgroup.npow_mem_zpowers Subgroup.npow_mem_zpowers
 
-/- warning: subgroup.forall_zpowers -> Subgroup.forall_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) -> Prop}, Iff (forall (g : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (forall (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x m)))))
-Case conversion may be inaccurate. Consider using '#align subgroup.forall_zpowers Subgroup.forall_zpowersₓ'. -/
 @[simp]
 theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=
   Set.forall_subtype_range_iff
 #align subgroup.forall_zpowers Subgroup.forall_zpowers
 
-/- warning: subgroup.exists_zpowers -> Subgroup.exists_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) -> Prop}, Iff (Exists.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) (fun (g : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (Exists.{succ u1} (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) (fun (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x m))))))
-Case conversion may be inaccurate. Consider using '#align subgroup.exists_zpowers Subgroup.exists_zpowersₓ'. -/
 @[simp]
 theorem exists_zpowers {x : G} {p : zpowers x → Prop} : (∃ g, p g) ↔ ∃ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=
   Set.exists_subtype_range_iff
 #align subgroup.exists_zpowers Subgroup.exists_zpowers
 
-/- warning: subgroup.forall_mem_zpowers -> Subgroup.forall_mem_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : G -> Prop}, Iff (forall (g : G), (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g (Subgroup.zpowers.{u1} G _inst_1 x)) -> (p g)) (forall (m : Int), p (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : G -> Prop}, Iff (forall (g : G), (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g (Subgroup.zpowers.{u1} G _inst_1 x)) -> (p g)) (forall (m : Int), p (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m))
-Case conversion may be inaccurate. Consider using '#align subgroup.forall_mem_zpowers Subgroup.forall_mem_zpowersₓ'. -/
 theorem forall_mem_zpowers {x : G} {p : G → Prop} : (∀ g ∈ zpowers x, p g) ↔ ∀ m : ℤ, p (x ^ m) :=
   Set.forall_range_iff
 #align subgroup.forall_mem_zpowers Subgroup.forall_mem_zpowers
 
-/- warning: subgroup.exists_mem_zpowers -> Subgroup.exists_mem_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : G -> Prop}, Iff (Exists.{succ u1} G (fun (g : G) => Exists.{0} (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g (Subgroup.zpowers.{u1} G _inst_1 x)) (fun (H : Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g (Subgroup.zpowers.{u1} G _inst_1 x)) => p g))) (Exists.{1} Int (fun (m : Int) => p (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : G -> Prop}, Iff (Exists.{succ u1} G (fun (g : G) => And (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g (Subgroup.zpowers.{u1} G _inst_1 x)) (p g))) (Exists.{1} Int (fun (m : Int) => p (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)))
-Case conversion may be inaccurate. Consider using '#align subgroup.exists_mem_zpowers Subgroup.exists_mem_zpowersₓ'. -/
 theorem exists_mem_zpowers {x : G} {p : G → Prop} : (∃ g ∈ zpowers x, p g) ↔ ∃ m : ℤ, p (x ^ m) :=
   Set.exists_range_iff
 #align subgroup.exists_mem_zpowers Subgroup.exists_mem_zpowers
@@ -198,23 +144,11 @@ section Ring
 
 variable {R : Type _} [Ring R] (r : R) (k : ℤ)
 
-/- warning: add_subgroup.int_cast_mul_mem_zmultiples -> AddSubgroup.int_cast_mul_mem_zmultiples is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (r : R) (k : Int), Membership.Mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) R (AddSubgroup.setLike.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_4))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))))) k) r) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))) r)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (r : R) (k : Int), Membership.mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) R (AddSubgroup.instSetLikeAddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) (Int.cast.{u1} R (Ring.toIntCast.{u1} R _inst_4) k) r) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)) r)
-Case conversion may be inaccurate. Consider using '#align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.int_cast_mul_mem_zmultiplesₓ'. -/
 @[simp]
 theorem int_cast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
   simpa only [← zsmul_eq_mul] using zsmul_mem_zmultiples r k
 #align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.int_cast_mul_mem_zmultiples
 
-/- warning: add_subgroup.int_cast_mem_zmultiples_one -> AddSubgroup.int_cast_mem_zmultiples_one is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.Mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) R (AddSubgroup.setLike.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))))) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))) (OfNat.ofNat.{u1} R 1 (OfNat.mk.{u1} R 1 (One.one.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) R (AddSubgroup.instSetLikeAddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)))) (Int.cast.{u1} R (Ring.toIntCast.{u1} R _inst_4) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)) (OfNat.ofNat.{u1} R 1 (One.toOfNat1.{u1} R (Semiring.toOne.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))
-Case conversion may be inaccurate. Consider using '#align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.int_cast_mem_zmultiples_oneₓ'. -/
 @[simp]
 theorem int_cast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R) :=
   mem_zmultiples_iff.mp ⟨k, by simp⟩
@@ -224,12 +158,6 @@ end Ring
 
 end AddSubgroup
 
-/- warning: monoid_hom.map_zpowers -> MonoidHom.map_zpowers is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {N : Type.{u2}} [_inst_3 : Group.{u2} N] (f : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (x : G), Eq.{succ u2} (Subgroup.{u2} N _inst_3) (Subgroup.map.{u1, u2} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u1} G _inst_1 x)) (Subgroup.zpowers.{u2} N _inst_3 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (fun (_x : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) => G -> N) (MonoidHom.hasCoeToFun.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) f x))
-but is expected to have type
-  forall {G : Type.{u2}} [_inst_1 : Group.{u2} G] {N : Type.{u1}} [_inst_3 : Group.{u1} N] (f : MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (x : G), Eq.{succ u1} (Subgroup.{u1} N _inst_3) (Subgroup.map.{u2, u1} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u2} G _inst_1 x)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) x) _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))))) f x))
-Case conversion may be inaccurate. Consider using '#align monoid_hom.map_zpowers MonoidHom.map_zpowersₓ'. -/
 @[simp, to_additive map_zmultiples]
 theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
     (Subgroup.zpowers x).map f = Subgroup.zpowers (f x) := by
@@ -237,22 +165,10 @@ theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
 #align monoid_hom.map_zpowers MonoidHom.map_zpowers
 #align add_monoid_hom.map_zmultiples AddMonoidHom.map_zmultiples
 
-/- warning: int.mem_zmultiples_iff -> Int.mem_zmultiples_iff is a dubious translation:
-lean 3 declaration is
-  forall {a : Int} {b : Int}, Iff (Membership.Mem.{0, 0} Int (AddSubgroup.{0} Int Int.addGroup) (SetLike.hasMem.{0, 0} (AddSubgroup.{0} Int Int.addGroup) Int (AddSubgroup.setLike.{0} Int Int.addGroup)) b (AddSubgroup.zmultiples.{0} Int Int.addGroup a)) (Dvd.Dvd.{0} Int (semigroupDvd.{0} Int Int.semigroup) a b)
-but is expected to have type
-  forall {a : Int} {b : Int}, Iff (Membership.mem.{0, 0} Int (AddSubgroup.{0} Int Int.instAddGroupInt) (SetLike.instMembership.{0, 0} (AddSubgroup.{0} Int Int.instAddGroupInt) Int (AddSubgroup.instSetLikeAddSubgroup.{0} Int Int.instAddGroupInt)) b (AddSubgroup.zmultiples.{0} Int Int.instAddGroupInt a)) (Dvd.dvd.{0} Int Int.instDvdInt a b)
-Case conversion may be inaccurate. Consider using '#align int.mem_zmultiples_iff Int.mem_zmultiples_iffₓ'. -/
 theorem Int.mem_zmultiples_iff {a b : ℤ} : b ∈ AddSubgroup.zmultiples a ↔ a ∣ b :=
   exists_congr fun k => by rw [mul_comm, eq_comm, ← smul_eq_mul]
 #align int.mem_zmultiples_iff Int.mem_zmultiples_iff
 
-/- warning: of_mul_image_zpowers_eq_zmultiples_of_mul -> ofMul_image_zpowers_eq_zmultiples_ofMul is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) (fun (_x : Equiv.{succ u1, succ u1} G (Additive.{u1} G)) => G -> (Additive.{u1} G)) (Equiv.hasCoeToFun.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} G _inst_1) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (HasLiftT.mk.{succ u1, succ u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (SetLike.Set.hasCoeT.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1))))) (AddSubgroup.zmultiples.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) (fun (_x : Equiv.{succ u1, succ u1} G (Additive.{u1} G)) => G -> (Additive.{u1} G)) (Equiv.hasCoeToFun.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (AddSubgroup.zmultiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
-Case conversion may be inaccurate. Consider using '#align of_mul_image_zpowers_eq_zmultiples_of_mul ofMul_image_zpowers_eq_zmultiples_ofMulₓ'. -/
 theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
     Additive.ofMul '' (Subgroup.zpowers x : Set G) = AddSubgroup.zmultiples (Additive.ofMul x) :=
   by
@@ -267,12 +183,6 @@ theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
     rwa [ofMul_zpow]
 #align of_mul_image_zpowers_eq_zmultiples_of_mul ofMul_image_zpowers_eq_zmultiples_ofMul
 
-/- warning: of_add_image_zmultiples_eq_zpowers_of_add -> ofAdd_image_zmultiples_eq_zpowers_ofAdd is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (HasLiftT.mk.{succ u1, succ u1} (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (SetLike.Set.hasCoeT.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.setLike.{u1} A _inst_2)))) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.setLike.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2))))) (Subgroup.zpowers.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
-but is expected to have type
-  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.instSetLikeAddSubgroup.{u1} A _inst_2) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) (SetLike.coe.{u1, u1} (Subgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.instSetLikeSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
-Case conversion may be inaccurate. Consider using '#align of_add_image_zmultiples_eq_zpowers_of_add ofAdd_image_zmultiples_eq_zpowers_ofAddₓ'. -/
 theorem ofAdd_image_zmultiples_eq_zpowers_ofAdd {x : A} :
     Multiplicative.ofAdd '' (AddSubgroup.zmultiples x : Set A) =
       Subgroup.zpowers (Multiplicative.ofAdd x) :=
@@ -296,67 +206,31 @@ instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
 #align add_subgroup.zmultiples_is_commutative AddSubgroup.zmultiples_isCommutative
 -/
 
-/- warning: subgroup.zpowers_le -> Subgroup.zpowers_le is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, Iff (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g) H) (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g H)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, Iff (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u1} G _inst_1))))) (Subgroup.zpowers.{u1} G _inst_1 g) H) (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g H)
-Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_le Subgroup.zpowers_leₓ'. -/
 @[simp, to_additive zmultiples_le]
 theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
   rw [zpowers_eq_closure, closure_le, Set.singleton_subset_iff, SetLike.mem_coe]
 #align subgroup.zpowers_le Subgroup.zpowers_le
 #align add_subgroup.zmultiples_le AddSubgroup.zmultiples_le
 
-/- warning: subgroup.zpowers_le_of_mem -> Subgroup.zpowers_le_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g) H)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g H) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u1} G _inst_1))))) (Subgroup.zpowers.{u1} G _inst_1 g) H)
-Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_memₓ'. -/
 alias zpowers_le ↔ _ zpowers_le_of_mem
 #align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_mem
 
-/- warning: add_subgroup.zmultiples_le_of_mem -> AddSubgroup.zmultiples_le_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] {g : G} {H : AddSubgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (AddSubgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (AddSubgroup.{u1} G _inst_1) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)))) (AddSubgroup.zmultiples.{u1} G _inst_1 g) H)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] {g : G} {H : AddSubgroup.{u1} G _inst_1}, (Membership.mem.{u1, u1} G (AddSubgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.instSetLikeAddSubgroup.{u1} G _inst_1)) g H) -> (LE.le.{u1} (AddSubgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (AddSubgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubgroup.{u1} G _inst_1) (AddSubgroup.instCompleteLatticeAddSubgroup.{u1} G _inst_1))))) (AddSubgroup.zmultiples.{u1} G _inst_1 g) H)
-Case conversion may be inaccurate. Consider using '#align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_memₓ'. -/
 alias AddSubgroup.zmultiples_le ↔ _ _root_.add_subgroup.zmultiples_le_of_mem
 #align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_mem
 
 attribute [to_additive zmultiples_le_of_mem] zpowers_le_of_mem
 
-/- warning: subgroup.zpowers_eq_bot -> Subgroup.zpowers_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasBot.{u1} G _inst_1))) (Eq.{succ u1} G g (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instBotSubgroup.{u1} G _inst_1))) (Eq.{succ u1} G g (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_eq_bot Subgroup.zpowers_eq_botₓ'. -/
 @[simp, to_additive zmultiples_eq_bot]
 theorem zpowers_eq_bot {g : G} : zpowers g = ⊥ ↔ g = 1 := by rw [eq_bot_iff, zpowers_le, mem_bot]
 #align subgroup.zpowers_eq_bot Subgroup.zpowers_eq_bot
 #align add_subgroup.zmultiples_eq_bot AddSubgroup.zmultiples_eq_bot
 
-/- warning: subgroup.zpowers_ne_bot -> Subgroup.zpowers_ne_bot is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Ne.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasBot.{u1} G _inst_1))) (Ne.{succ u1} G g (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Ne.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instBotSubgroup.{u1} G _inst_1))) (Ne.{succ u1} G g (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_ne_bot Subgroup.zpowers_ne_botₓ'. -/
 @[to_additive zmultiples_ne_bot]
 theorem zpowers_ne_bot : zpowers g ≠ ⊥ ↔ g ≠ 1 :=
   zpowers_eq_bot.Not
 #align subgroup.zpowers_ne_bot Subgroup.zpowers_ne_bot
 #align add_subgroup.zmultiples_ne_bot AddSubgroup.zmultiples_ne_bot
 
-/- warning: subgroup.zpowers_one_eq_bot -> Subgroup.zpowers_one_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G], Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasBot.{u1} G _inst_1))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G], Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))))) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instBotSubgroup.{u1} G _inst_1))
-Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_one_eq_bot Subgroup.zpowers_one_eq_botₓ'. -/
 @[simp, to_additive zmultiples_zero_eq_bot]
 theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
   Subgroup.zpowers_eq_bot.mpr rfl
@@ -376,12 +250,6 @@ theorem centralizer_closure (S : Set G) :
 #align add_subgroup.centralizer_closure AddSubgroup.centralizer_closure
 -/
 
-/- warning: subgroup.center_eq_infi -> Subgroup.center_eq_iInf is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) G (fun (g : G) => iInf.{u1, 0} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) g S) (fun (H : Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) g S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 g)))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) G (fun (g : G) => iInf.{u1, 0} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) g S) (fun (H : Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) g S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 g)))))
-Case conversion may be inaccurate. Consider using '#align subgroup.center_eq_infi Subgroup.center_eq_iInfₓ'. -/
 @[to_additive]
 theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g ∈ S, centralizer (zpowers g) := by
@@ -389,12 +257,6 @@ theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
 #align subgroup.center_eq_infi Subgroup.center_eq_iInf
 #align add_subgroup.center_eq_infi AddSubgroup.center_eq_iInf
 
-/- warning: subgroup.center_eq_infi' -> Subgroup.center_eq_infi' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) (fun (g : coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) g)))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) (Set.Elem.{u1} G S) (fun (g : Set.Elem.{u1} G S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) g)))))
-Case conversion may be inaccurate. Consider using '#align subgroup.center_eq_infi' Subgroup.center_eq_infi'ₓ'. -/
 @[to_additive]
 theorem center_eq_infi' (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g : S, centralizer (zpowers g) := by rw [center_eq_infi S hS, ← iInf_subtype'']

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -60,9 +60,7 @@ theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range fun n : ℤ => g ^ n :=
 #align subgroup.coe_zpowers Subgroup.coe_zpowers
 
 #print Subgroup.zpowers_eq_closure /-
-theorem zpowers_eq_closure (g : G) : zpowers g = closure {g} :=
-  by
-  ext
+theorem zpowers_eq_closure (g : G) : zpowers g = closure {g} := by ext;
   exact mem_closure_singleton.symm
 #align subgroup.zpowers_eq_closure Subgroup.zpowers_eq_closure
 -/

bump to nightly-2023-05-19-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/95a87616d63b3cb49d3fe678d416fbe9c4217bf4

a31df521

Diff

@@ -230,7 +230,7 @@ end AddSubgroup
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {N : Type.{u2}} [_inst_3 : Group.{u2} N] (f : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (x : G), Eq.{succ u2} (Subgroup.{u2} N _inst_3) (Subgroup.map.{u1, u2} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u1} G _inst_1 x)) (Subgroup.zpowers.{u2} N _inst_3 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (fun (_x : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) => G -> N) (MonoidHom.hasCoeToFun.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) f x))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_1 : Group.{u2} G] {N : Type.{u1}} [_inst_3 : Group.{u1} N] (f : MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (x : G), Eq.{succ u1} (Subgroup.{u1} N _inst_3) (Subgroup.map.{u2, u1} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u2} G _inst_1 x)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) x) _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))))) f x))
+  forall {G : Type.{u2}} [_inst_1 : Group.{u2} G] {N : Type.{u1}} [_inst_3 : Group.{u1} N] (f : MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (x : G), Eq.{succ u1} (Subgroup.{u1} N _inst_3) (Subgroup.map.{u2, u1} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u2} G _inst_1 x)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) x) _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))))) f x))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_zpowers MonoidHom.map_zpowersₓ'. -/
 @[simp, to_additive map_zmultiples]
 theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
@@ -253,7 +253,7 @@ theorem Int.mem_zmultiples_iff {a b : ℤ} : b ∈ AddSubgroup.zmultiples a ↔
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) (fun (_x : Equiv.{succ u1, succ u1} G (Additive.{u1} G)) => G -> (Additive.{u1} G)) (Equiv.hasCoeToFun.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} G _inst_1) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (HasLiftT.mk.{succ u1, succ u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (SetLike.Set.hasCoeT.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1))))) (AddSubgroup.zmultiples.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) (fun (_x : Equiv.{succ u1, succ u1} G (Additive.{u1} G)) => G -> (Additive.{u1} G)) (Equiv.hasCoeToFun.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (AddSubgroup.zmultiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (AddSubgroup.zmultiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
 Case conversion may be inaccurate. Consider using '#align of_mul_image_zpowers_eq_zmultiples_of_mul ofMul_image_zpowers_eq_zmultiples_ofMulₓ'. -/
 theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
     Additive.ofMul '' (Subgroup.zpowers x : Set G) = AddSubgroup.zmultiples (Additive.ofMul x) :=
@@ -273,7 +273,7 @@ theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
 lean 3 declaration is
   forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (HasLiftT.mk.{succ u1, succ u1} (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (SetLike.Set.hasCoeT.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.setLike.{u1} A _inst_2)))) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.setLike.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2))))) (Subgroup.zpowers.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 but is expected to have type
-  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.instSetLikeAddSubgroup.{u1} A _inst_2) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) (SetLike.coe.{u1, u1} (Subgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.instSetLikeSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
+  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.instSetLikeAddSubgroup.{u1} A _inst_2) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) (SetLike.coe.{u1, u1} (Subgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.instSetLikeSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 Case conversion may be inaccurate. Consider using '#align of_add_image_zmultiples_eq_zpowers_of_add ofAdd_image_zmultiples_eq_zpowers_ofAddₓ'. -/
 theorem ofAdd_image_zmultiples_eq_zpowers_ofAdd {x : A} :
     Multiplicative.ofAdd '' (AddSubgroup.zmultiples x : Set A) =

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -300,7 +300,7 @@ instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
 
 /- warning: subgroup.zpowers_le -> Subgroup.zpowers_le is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, Iff (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g) H) (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g H)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, Iff (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g) H) (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g H)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, Iff (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u1} G _inst_1))))) (Subgroup.zpowers.{u1} G _inst_1 g) H) (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g H)
 Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_le Subgroup.zpowers_leₓ'. -/
@@ -312,7 +312,7 @@ theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
 
 /- warning: subgroup.zpowers_le_of_mem -> Subgroup.zpowers_le_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g) H)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g) H)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g H) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u1} G _inst_1))))) (Subgroup.zpowers.{u1} G _inst_1 g) H)
 Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_memₓ'. -/
@@ -321,7 +321,7 @@ alias zpowers_le ↔ _ zpowers_le_of_mem
 
 /- warning: add_subgroup.zmultiples_le_of_mem -> AddSubgroup.zmultiples_le_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] {g : G} {H : AddSubgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (AddSubgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (AddSubgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (AddSubgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)))) (AddSubgroup.zmultiples.{u1} G _inst_1 g) H)
+  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] {g : G} {H : AddSubgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (AddSubgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (AddSubgroup.{u1} G _inst_1) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)))) (AddSubgroup.zmultiples.{u1} G _inst_1 g) H)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] {g : G} {H : AddSubgroup.{u1} G _inst_1}, (Membership.mem.{u1, u1} G (AddSubgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.instSetLikeAddSubgroup.{u1} G _inst_1)) g H) -> (LE.le.{u1} (AddSubgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (AddSubgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubgroup.{u1} G _inst_1) (AddSubgroup.instCompleteLatticeAddSubgroup.{u1} G _inst_1))))) (AddSubgroup.zmultiples.{u1} G _inst_1 g) H)
 Case conversion may be inaccurate. Consider using '#align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_memₓ'. -/

bump to nightly-2023-05-14-08

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

d31da313

Diff

@@ -370,36 +370,36 @@ theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
 theorem centralizer_closure (S : Set G) :
     (closure S).centralizer = ⨅ g ∈ S, (zpowers g).centralizer :=
   le_antisymm
-      (le_infᵢ fun g => le_infᵢ fun hg => centralizer_le <| zpowers_le.2 <| subset_closure hg) <|
+      (le_iInf fun g => le_iInf fun hg => centralizer_le <| zpowers_le.2 <| subset_closure hg) <|
     le_centralizer_iff.1 <|
       (closure_le _).2 fun g =>
-        SetLike.mem_coe.2 ∘ zpowers_le.1 ∘ le_centralizer_iff.1 ∘ infᵢ_le_of_le g ∘ infᵢ_le _
+        SetLike.mem_coe.2 ∘ zpowers_le.1 ∘ le_centralizer_iff.1 ∘ iInf_le_of_le g ∘ iInf_le _
 #align subgroup.centralizer_closure Subgroup.centralizer_closure
 #align add_subgroup.centralizer_closure AddSubgroup.centralizer_closure
 -/
 
-/- warning: subgroup.center_eq_infi -> Subgroup.center_eq_infᵢ is a dubious translation:
+/- warning: subgroup.center_eq_infi -> Subgroup.center_eq_iInf is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (infᵢ.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) G (fun (g : G) => infᵢ.{u1, 0} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) g S) (fun (H : Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) g S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 g)))))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) G (fun (g : G) => iInf.{u1, 0} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) g S) (fun (H : Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) g S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 g)))))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (infᵢ.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) G (fun (g : G) => infᵢ.{u1, 0} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) g S) (fun (H : Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) g S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 g)))))
-Case conversion may be inaccurate. Consider using '#align subgroup.center_eq_infi Subgroup.center_eq_infᵢₓ'. -/
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) G (fun (g : G) => iInf.{u1, 0} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) g S) (fun (H : Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) g S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 g)))))
+Case conversion may be inaccurate. Consider using '#align subgroup.center_eq_infi Subgroup.center_eq_iInfₓ'. -/
 @[to_additive]
-theorem center_eq_infᵢ (S : Set G) (hS : closure S = ⊤) :
+theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g ∈ S, centralizer (zpowers g) := by
   rw [← centralizer_top, ← hS, centralizer_closure]
-#align subgroup.center_eq_infi Subgroup.center_eq_infᵢ
-#align add_subgroup.center_eq_infi AddSubgroup.center_eq_infᵢ
+#align subgroup.center_eq_infi Subgroup.center_eq_iInf
+#align add_subgroup.center_eq_infi AddSubgroup.center_eq_iInf
 
 /- warning: subgroup.center_eq_infi' -> Subgroup.center_eq_infi' is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (infᵢ.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) (fun (g : coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) g)))))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasTop.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasInf.{u1} G _inst_1) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) (fun (g : coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) S) G (coeSubtype.{succ u1} G (fun (x : G) => Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x S))))) g)))))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (infᵢ.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) (Set.Elem.{u1} G S) (fun (g : Set.Elem.{u1} G S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) g)))))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (S : Set.{u1} G), (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.closure.{u1} G _inst_1 S) (Top.top.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instTopSubgroup.{u1} G _inst_1))) -> (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.center.{u1} G _inst_1) (iInf.{u1, succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.instInfSetSubgroup.{u1} G _inst_1) (Set.Elem.{u1} G S) (fun (g : Set.Elem.{u1} G S) => Subgroup.centralizer.{u1} G _inst_1 (Subgroup.zpowers.{u1} G _inst_1 (Subtype.val.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x S) g)))))
 Case conversion may be inaccurate. Consider using '#align subgroup.center_eq_infi' Subgroup.center_eq_infi'ₓ'. -/
 @[to_additive]
 theorem center_eq_infi' (S : Set G) (hS : closure S = ⊤) :
-    center G = ⨅ g : S, centralizer (zpowers g) := by rw [center_eq_infi S hS, ← infᵢ_subtype'']
+    center G = ⨅ g : S, centralizer (zpowers g) := by rw [center_eq_infi S hS, ← iInf_subtype'']
 #align subgroup.center_eq_infi' Subgroup.center_eq_infi'
 #align add_subgroup.center_eq_infi' AddSubgroup.center_eq_infi'

bump to nightly-2023-05-08-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/08e1d8d4d989df3a6df86f385e9053ec8a372cc1

63e712c6

Diff

@@ -215,7 +215,7 @@ theorem int_cast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
 lean 3 declaration is
   forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.Mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) R (AddSubgroup.setLike.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))))) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))) (OfNat.ofNat.{u1} R 1 (OfNat.mk.{u1} R 1 (One.one.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))))))
 but is expected to have type
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) R (AddSubgroup.instSetLikeAddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)))) (Int.cast.{u1} R (Ring.toIntCast.{u1} R _inst_4) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)) (OfNat.ofNat.{u1} R 1 (One.toOfNat1.{u1} R (NonAssocRing.toOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))))
+  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) R (AddSubgroup.instSetLikeAddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)))) (Int.cast.{u1} R (Ring.toIntCast.{u1} R _inst_4) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)) (OfNat.ofNat.{u1} R 1 (One.toOfNat1.{u1} R (Semiring.toOne.{u1} R (Ring.toSemiring.{u1} R _inst_4)))))
 Case conversion may be inaccurate. Consider using '#align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.int_cast_mem_zmultiples_oneₓ'. -/
 @[simp]
 theorem int_cast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R) :=

bump to nightly-2023-04-28-06

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

66f53cf6

Diff

@@ -110,7 +110,7 @@ theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) -> Prop}, Iff (forall (g : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)))))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (forall (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x m)))))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (forall (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x m)))))
 Case conversion may be inaccurate. Consider using '#align subgroup.forall_zpowers Subgroup.forall_zpowersₓ'. -/
 @[simp]
 theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=
@@ -121,7 +121,7 @@ theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) -> Prop}, Iff (Exists.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) (fun (g : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m))))))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (Exists.{succ u1} (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) (fun (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x m))))))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (Exists.{succ u1} (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) (fun (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.ZPowers._hyg.77) x m))))))
 Case conversion may be inaccurate. Consider using '#align subgroup.exists_zpowers Subgroup.exists_zpowersₓ'. -/
 @[simp]
 theorem exists_zpowers {x : G} {p : zpowers x → Prop} : (∃ g, p g) ↔ ∃ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=

bump to nightly-2023-04-12-12

mathlib commit https://github.com/leanprover-community/mathlib/commit/039ef89bef6e58b32b62898dd48e9d1a4312bb65

7180b7a4

Diff

@@ -48,6 +48,12 @@ theorem mem_zpowers (g : G) : g ∈ zpowers g :=
   ⟨1, zpow_one _⟩
 #align subgroup.mem_zpowers Subgroup.mem_zpowers
 
+/- warning: subgroup.coe_zpowers -> Subgroup.coe_zpowers is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} (Set.{u1} G) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} G _inst_1) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g)) (Set.range.{u1, 1} G Int (fun (n : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g n))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (g : G), Eq.{succ u1} (Set.{u1} G) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g)) (Set.range.{u1, 1} G Int (fun (n : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g n))
+Case conversion may be inaccurate. Consider using '#align subgroup.coe_zpowers Subgroup.coe_zpowersₓ'. -/
 @[norm_cast]
 theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range fun n : ℤ => g ^ n :=
   rfl
@@ -304,9 +310,21 @@ theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
 #align subgroup.zpowers_le Subgroup.zpowers_le
 #align add_subgroup.zmultiples_le AddSubgroup.zmultiples_le
 
+/- warning: subgroup.zpowers_le_of_mem -> Subgroup.zpowers_le_of_mem is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 g) H)
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {H : Subgroup.{u1} G _inst_1}, (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) g H) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u1} G _inst_1))))) (Subgroup.zpowers.{u1} G _inst_1 g) H)
+Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_memₓ'. -/
 alias zpowers_le ↔ _ zpowers_le_of_mem
 #align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_mem
 
+/- warning: add_subgroup.zmultiples_le_of_mem -> AddSubgroup.zmultiples_le_of_mem is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] {g : G} {H : AddSubgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (AddSubgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)) g H) -> (LE.le.{u1} (AddSubgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (AddSubgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.setLike.{u1} G _inst_1)))) (AddSubgroup.zmultiples.{u1} G _inst_1 g) H)
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : AddGroup.{u1} G] {g : G} {H : AddSubgroup.{u1} G _inst_1}, (Membership.mem.{u1, u1} G (AddSubgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} G _inst_1) G (AddSubgroup.instSetLikeAddSubgroup.{u1} G _inst_1)) g H) -> (LE.le.{u1} (AddSubgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (AddSubgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubgroup.{u1} G _inst_1) (AddSubgroup.instCompleteLatticeAddSubgroup.{u1} G _inst_1))))) (AddSubgroup.zmultiples.{u1} G _inst_1 g) H)
+Case conversion may be inaccurate. Consider using '#align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_memₓ'. -/
 alias AddSubgroup.zmultiples_le ↔ _ _root_.add_subgroup.zmultiples_le_of_mem
 #align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_mem
 
@@ -323,6 +341,12 @@ theorem zpowers_eq_bot {g : G} : zpowers g = ⊥ ↔ g = 1 := by rw [eq_bot_iff,
 #align subgroup.zpowers_eq_bot Subgroup.zpowers_eq_bot
 #align add_subgroup.zmultiples_eq_bot AddSubgroup.zmultiples_eq_bot
 
+/- warning: subgroup.zpowers_ne_bot -> Subgroup.zpowers_ne_bot is a dubious translation:
+lean 3 declaration is
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Ne.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasBot.{u1} G _inst_1))) (Ne.{succ u1} G g (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))))
+but is expected to have type
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Ne.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instBotSubgroup.{u1} G _inst_1))) (Ne.{succ u1} G g (OfNat.ofNat.{u1} G 1 (One.toOfNat1.{u1} G (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))))))
+Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_ne_bot Subgroup.zpowers_ne_botₓ'. -/
 @[to_additive zmultiples_ne_bot]
 theorem zpowers_ne_bot : zpowers g ≠ ⊥ ↔ g ≠ 1 :=
   zpowers_eq_bot.Not

bump to nightly-2023-04-05-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/1a4df69ca1a9a0e5e26bfe12e2b92814216016d0

ea95f542

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module group_theory.subgroup.zpowers
-! leanprover-community/mathlib commit a11f9106a169dd302a285019e5165f8ab32ff433
+! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -48,6 +48,11 @@ theorem mem_zpowers (g : G) : g ∈ zpowers g :=
   ⟨1, zpow_one _⟩
 #align subgroup.mem_zpowers Subgroup.mem_zpowers
 
+@[norm_cast]
+theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range fun n : ℤ => g ^ n :=
+  rfl
+#align subgroup.coe_zpowers Subgroup.coe_zpowers
+
 #print Subgroup.zpowers_eq_closure /-
 theorem zpowers_eq_closure (g : G) : zpowers g = closure {g} :=
   by
@@ -63,17 +68,6 @@ theorem range_zpowersHom (g : G) : (zpowersHom G g).range = zpowers g :=
 #align subgroup.range_zpowers_hom Subgroup.range_zpowersHom
 -/
 
-/- warning: subgroup.zpowers_subset -> Subgroup.zpowers_subset is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {a : G} {K : Subgroup.{u1} G _inst_1}, (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) a K) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 a) K)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {a : G} {K : Subgroup.{u1} G _inst_1}, (Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) a K) -> (LE.le.{u1} (Subgroup.{u1} G _inst_1) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_1) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Subgroup.{u1} G _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.instCompleteLatticeSubgroup.{u1} G _inst_1))))) (Subgroup.zpowers.{u1} G _inst_1 a) K)
-Case conversion may be inaccurate. Consider using '#align subgroup.zpowers_subset Subgroup.zpowers_subsetₓ'. -/
-theorem zpowers_subset {a : G} {K : Subgroup G} (h : a ∈ K) : zpowers a ≤ K := fun x hx =>
-  match x, hx with
-  | _, ⟨i, rfl⟩ => K.zpow_mem h i
-#align subgroup.zpowers_subset Subgroup.zpowers_subset
-
 /- warning: subgroup.mem_zpowers_iff -> Subgroup.mem_zpowers_iff is a dubious translation:
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G} {h : G}, Iff (Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) h (Subgroup.zpowers.{u1} G _inst_1 g)) (Exists.{1} Int (fun (k : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) g k) h))
@@ -173,12 +167,12 @@ attribute [to_additive AddSubgroup.zmultiples] Subgroup.zpowers
 
 attribute [to_additive AddSubgroup.mem_zmultiples] Subgroup.mem_zpowers
 
+attribute [to_additive AddSubgroup.coe_zmultiples] Subgroup.coe_zpowers
+
 attribute [to_additive AddSubgroup.zmultiples_eq_closure] Subgroup.zpowers_eq_closure
 
 attribute [to_additive AddSubgroup.range_zmultiplesHom] Subgroup.range_zpowersHom
 
-attribute [to_additive AddSubgroup.zmultiples_subset] Subgroup.zpowers_subset
-
 attribute [to_additive AddSubgroup.mem_zmultiples_iff] Subgroup.mem_zpowers_iff
 
 attribute [to_additive AddSubgroup.zsmul_mem_zmultiples] Subgroup.zpow_mem_zpowers
@@ -286,6 +280,8 @@ theorem ofAdd_image_zmultiples_eq_zpowers_ofAdd {x : A} :
 
 namespace Subgroup
 
+variable {s : Set G} {g : G}
+
 #print Subgroup.zpowers_isCommutative /-
 @[to_additive zmultiples_is_commutative]
 instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
@@ -308,6 +304,14 @@ theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
 #align subgroup.zpowers_le Subgroup.zpowers_le
 #align add_subgroup.zmultiples_le AddSubgroup.zmultiples_le
 
+alias zpowers_le ↔ _ zpowers_le_of_mem
+#align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_mem
+
+alias AddSubgroup.zmultiples_le ↔ _ _root_.add_subgroup.zmultiples_le_of_mem
+#align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_mem
+
+attribute [to_additive zmultiples_le_of_mem] zpowers_le_of_mem
+
 /- warning: subgroup.zpowers_eq_bot -> Subgroup.zpowers_eq_bot is a dubious translation:
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 g) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasBot.{u1} G _inst_1))) (Eq.{succ u1} G g (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))))
@@ -319,6 +323,12 @@ theorem zpowers_eq_bot {g : G} : zpowers g = ⊥ ↔ g = 1 := by rw [eq_bot_iff,
 #align subgroup.zpowers_eq_bot Subgroup.zpowers_eq_bot
 #align add_subgroup.zmultiples_eq_bot AddSubgroup.zmultiples_eq_bot
 
+@[to_additive zmultiples_ne_bot]
+theorem zpowers_ne_bot : zpowers g ≠ ⊥ ↔ g ≠ 1 :=
+  zpowers_eq_bot.Not
+#align subgroup.zpowers_ne_bot Subgroup.zpowers_ne_bot
+#align add_subgroup.zmultiples_ne_bot AddSubgroup.zmultiples_ne_bot
+
 /- warning: subgroup.zpowers_one_eq_bot -> Subgroup.zpowers_one_eq_bot is a dubious translation:
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G], Eq.{succ u1} (Subgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 (OfNat.ofNat.{u1} G 1 (OfNat.mk.{u1} G 1 (One.one.{u1} G (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))))) (Bot.bot.{u1} (Subgroup.{u1} G _inst_1) (Subgroup.hasBot.{u1} G _inst_1))

bump to nightly-2023-03-27-02

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

0e4ebd8c

Diff

@@ -202,7 +202,7 @@ variable {R : Type _} [Ring R] (r : R) (k : ℤ)
 
 /- warning: add_subgroup.int_cast_mul_mem_zmultiples -> AddSubgroup.int_cast_mul_mem_zmultiples is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (r : R) (k : Int), Membership.Mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) R (AddSubgroup.setLike.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_4))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))))) k) r) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4))) r)
+  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (r : R) (k : Int), Membership.Mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) R (AddSubgroup.setLike.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (Ring.toDistrib.{u1} R _inst_4))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))))) k) r) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))) r)
 but is expected to have type
   forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (r : R) (k : Int), Membership.mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) R (AddSubgroup.instSetLikeAddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocRing.toMul.{u1} R (NonAssocRing.toNonUnitalNonAssocRing.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) (Int.cast.{u1} R (Ring.toIntCast.{u1} R _inst_4) k) r) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)) r)
 Case conversion may be inaccurate. Consider using '#align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.int_cast_mul_mem_zmultiplesₓ'. -/
@@ -213,7 +213,7 @@ theorem int_cast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
 
 /- warning: add_subgroup.int_cast_mem_zmultiples_one -> AddSubgroup.int_cast_mem_zmultiples_one is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.Mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))) R (AddSubgroup.setLike.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))))) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4))) (OfNat.ofNat.{u1} R 1 (OfNat.mk.{u1} R 1 (One.one.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (NonAssocRing.toAddGroupWithOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4))))))))
+  forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.Mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) (SetLike.hasMem.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))) R (AddSubgroup.setLike.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Int R (HasLiftT.mk.{1, succ u1} Int R (CoeTCₓ.coe.{1, succ u1} Int R (Int.castCoe.{u1} R (AddGroupWithOne.toHasIntCast.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4)))))) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))) (OfNat.ofNat.{u1} R 1 (OfNat.mk.{u1} R 1 (One.one.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddGroupWithOne.toAddMonoidWithOne.{u1} R (AddCommGroupWithOne.toAddGroupWithOne.{u1} R (Ring.toAddCommGroupWithOne.{u1} R _inst_4))))))))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_4 : Ring.{u1} R] (k : Int), Membership.mem.{u1, u1} R (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) (SetLike.instMembership.{u1, u1} (AddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4))) R (AddSubgroup.instSetLikeAddSubgroup.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)))) (Int.cast.{u1} R (Ring.toIntCast.{u1} R _inst_4) k) (AddSubgroup.zmultiples.{u1} R (AddGroupWithOne.toAddGroup.{u1} R (Ring.toAddGroupWithOne.{u1} R _inst_4)) (OfNat.ofNat.{u1} R 1 (One.toOfNat1.{u1} R (NonAssocRing.toOne.{u1} R (Ring.toNonAssocRing.{u1} R _inst_4)))))
 Case conversion may be inaccurate. Consider using '#align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.int_cast_mem_zmultiples_oneₓ'. -/

bump to nightly-2023-03-11-22

mathlib commit https://github.com/leanprover-community/mathlib/commit/3180fab693e2cee3bff62675571264cb8778b212

a8ee822f

Diff

@@ -110,7 +110,7 @@ theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) -> Prop}, Iff (forall (g : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)))))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (forall (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76) x m)))))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (forall (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))), p g) (forall (m : Int), p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x m)))))
 Case conversion may be inaccurate. Consider using '#align subgroup.forall_zpowers Subgroup.forall_zpowersₓ'. -/
 @[simp]
 theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=
@@ -121,7 +121,7 @@ theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) -> Prop}, Iff (Exists.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) (fun (g : coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_1) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) (Subgroup.zpowers.{u1} G _inst_1 x)) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.Mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.hasMem.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m))))))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (Exists.{succ u1} (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) (fun (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.74 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.76) x m))))))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G} {p : (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) -> Prop}, Iff (Exists.{succ u1} (Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) (fun (g : Subtype.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x))) => p g)) (Exists.{1} Int (fun (m : Int) => p (Subtype.mk.{succ u1} G (fun (x_1 : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_1) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1)) x_1 (Subgroup.zpowers.{u1} G _inst_1 x)) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m) (Exists.intro.{1} Int (fun (y : Int) => Eq.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x y) (HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x m)) m (rfl.{succ u1} G ((fun (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 : G) (x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77 : Int) => HPow.hPow.{u1, 0, u1} G Int G (instHPow.{u1, 0} G Int (DivInvMonoid.Pow.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.75 x._@.Mathlib.GroupTheory.Subgroup.Zpowers._hyg.77) x m))))))
 Case conversion may be inaccurate. Consider using '#align subgroup.exists_zpowers Subgroup.exists_zpowersₓ'. -/
 @[simp]
 theorem exists_zpowers {x : G} {p : zpowers x → Prop} : (∃ g, p g) ↔ ∃ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=
@@ -230,7 +230,7 @@ end AddSubgroup
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {N : Type.{u2}} [_inst_3 : Group.{u2} N] (f : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (x : G), Eq.{succ u2} (Subgroup.{u2} N _inst_3) (Subgroup.map.{u1, u2} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u1} G _inst_1 x)) (Subgroup.zpowers.{u2} N _inst_3 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (fun (_x : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) => G -> N) (MonoidHom.hasCoeToFun.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) f x))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_1 : Group.{u2} G] {N : Type.{u1}} [_inst_3 : Group.{u1} N] (f : MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (x : G), Eq.{succ u1} (Subgroup.{u1} N _inst_3) (Subgroup.map.{u2, u1} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u2} G _inst_1 x)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) x) _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))))) f x))
+  forall {G : Type.{u2}} [_inst_1 : Group.{u2} G] {N : Type.{u1}} [_inst_3 : Group.{u1} N] (f : MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (x : G), Eq.{succ u1} (Subgroup.{u1} N _inst_3) (Subgroup.map.{u2, u1} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u2} G _inst_1 x)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) x) _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))))) f x))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_zpowers MonoidHom.map_zpowersₓ'. -/
 @[simp, to_additive map_zmultiples]
 theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
@@ -253,7 +253,7 @@ theorem Int.mem_zmultiples_iff {a b : ℤ} : b ∈ AddSubgroup.zmultiples a ↔
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) (fun (_x : Equiv.{succ u1, succ u1} G (Additive.{u1} G)) => G -> (Additive.{u1} G)) (Equiv.hasCoeToFun.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} G _inst_1) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} G _inst_1) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.setLike.{u1} G _inst_1)))) (Subgroup.zpowers.{u1} G _inst_1 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (HasLiftT.mk.{succ u1, succ u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Set.{u1} (Additive.{u1} G)) (SetLike.Set.hasCoeT.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1))))) (AddSubgroup.zmultiples.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) (fun (_x : Equiv.{succ u1, succ u1} G (Additive.{u1} G)) => G -> (Additive.{u1} G)) (Equiv.hasCoeToFun.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (AddSubgroup.zmultiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {x : G}, Eq.{succ u1} (Set.{u1} (Additive.{u1} G)) (Set.image.{u1, u1} G (Additive.{u1} G) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G)) (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) (Subgroup.zpowers.{u1} G _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1)) (AddSubgroup.zmultiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) x) (Additive.addGroup.{u1} G _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} G (Additive.{u1} G)) G (fun (_x : G) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : G) => Additive.{u1} G) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} G (Additive.{u1} G)) (Additive.ofMul.{u1} G) x)))
 Case conversion may be inaccurate. Consider using '#align of_mul_image_zpowers_eq_zmultiples_of_mul ofMul_image_zpowers_eq_zmultiples_ofMulₓ'. -/
 theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
     Additive.ofMul '' (Subgroup.zpowers x : Set G) = AddSubgroup.zmultiples (Additive.ofMul x) :=
@@ -273,7 +273,7 @@ theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
 lean 3 declaration is
   forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (HasLiftT.mk.{succ u1, succ u1} (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubgroup.{u1} A _inst_2) (Set.{u1} A) (SetLike.Set.hasCoeT.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.setLike.{u1} A _inst_2)))) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (HasLiftT.mk.{succ u1, succ u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (CoeTCₓ.coe.{succ u1, succ u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Set.{u1} (Multiplicative.{u1} A)) (SetLike.Set.hasCoeT.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.setLike.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2))))) (Subgroup.zpowers.{u1} (Multiplicative.{u1} A) (Multiplicative.group.{u1} A _inst_2) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 but is expected to have type
-  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.instSetLikeAddSubgroup.{u1} A _inst_2) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) (SetLike.coe.{u1, u1} (Subgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.instSetLikeSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
+  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubgroup.{u1} A _inst_2) A (AddSubgroup.instSetLikeAddSubgroup.{u1} A _inst_2) (AddSubgroup.zmultiples.{u1} A _inst_2 x))) (SetLike.coe.{u1, u1} (Subgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Multiplicative.{u1} A) (Subgroup.instSetLikeSubgroup.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.group.{u1} A _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 Case conversion may be inaccurate. Consider using '#align of_add_image_zmultiples_eq_zpowers_of_add ofAdd_image_zmultiples_eq_zpowers_ofAddₓ'. -/
 theorem ofAdd_image_zmultiples_eq_zpowers_ofAdd {x : A} :
     Multiplicative.ofAdd '' (AddSubgroup.zmultiples x : Set A) =

bump to nightly-2023-03-08-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

10f15343

Diff

@@ -230,7 +230,7 @@ end AddSubgroup
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {N : Type.{u2}} [_inst_3 : Group.{u2} N] (f : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (x : G), Eq.{succ u2} (Subgroup.{u2} N _inst_3) (Subgroup.map.{u1, u2} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u1} G _inst_1 x)) (Subgroup.zpowers.{u2} N _inst_3 (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) (fun (_x : MonoidHom.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) => G -> N) (MonoidHom.hasCoeToFun.{u1, u2} G N (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) (Monoid.toMulOneClass.{u2} N (DivInvMonoid.toMonoid.{u2} N (Group.toDivInvMonoid.{u2} N _inst_3)))) f x))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_1 : Group.{u2} G] {N : Type.{u1}} [_inst_3 : Group.{u1} N] (f : MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (x : G), Eq.{succ u1} (Subgroup.{u1} N _inst_3) (Subgroup.map.{u2, u1} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u2} G _inst_1 x)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) x) _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))))) f x))
+  forall {G : Type.{u2}} [_inst_1 : Group.{u2} G] {N : Type.{u1}} [_inst_3 : Group.{u1} N] (f : MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (x : G), Eq.{succ u1} (Subgroup.{u1} N _inst_3) (Subgroup.map.{u2, u1} G _inst_1 N _inst_3 f (Subgroup.zpowers.{u2} G _inst_1 x)) (Subgroup.zpowers.{u1} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) x) _inst_3 (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => N) _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))) (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))) G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3))) (MonoidHom.monoidHomClass.{u2, u1} G N (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (Monoid.toMulOneClass.{u1} N (DivInvMonoid.toMonoid.{u1} N (Group.toDivInvMonoid.{u1} N _inst_3)))))) f x))
 Case conversion may be inaccurate. Consider using '#align monoid_hom.map_zpowers MonoidHom.map_zpowersₓ'. -/
 @[simp, to_additive map_zmultiples]
 theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :

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

@@ -7,6 +7,8 @@ import Mathlib.GroupTheory.Subgroup.Basic
 import Mathlib.Data.Countable.Basic
 import Mathlib.Data.Set.Image
 import Mathlib.Data.Set.Subsingleton
+import Mathlib.Data.Int.Cast.Lemmas
+import Mathlib.GroupTheory.Subgroup.Centralizer
 
 #align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"

chore: split Subsingleton,Nontrivial off of Data.Set.Basic (#11832)

Moves definition of and lemmas related to Set.Subsingleton and Set.Nontrivial to a new file, so that Basic can be shorter.

493a947e

Diff

@@ -6,7 +6,7 @@ Authors: Chris Hughes
 import Mathlib.GroupTheory.Subgroup.Basic
 import Mathlib.Data.Countable.Basic
 import Mathlib.Data.Set.Image
-import Mathlib.Data.Set.Basic
+import Mathlib.Data.Set.Subsingleton
 
 #align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"

chore: Rename nat_cast/int_cast/rat_cast to natCast/intCast/ratCast (#11486)

Now that I am defining NNRat.cast, I want a definitive answer to this naming issue. Plenty of lemmas in mathlib already use natCast/intCast/ratCast over nat_cast/int_cast/rat_cast, and this matches with the general expectation that underscore-separated name parts correspond to a single declaration.

145460b9

Diff

@@ -143,14 +143,14 @@ section Ring
 variable {R : Type*} [Ring R] (r : R) (k : ℤ)
 
 @[simp]
-theorem int_cast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
+theorem intCast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
   simpa only [← zsmul_eq_mul] using zsmul_mem_zmultiples r k
-#align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.int_cast_mul_mem_zmultiples
+#align add_subgroup.int_cast_mul_mem_zmultiples AddSubgroup.intCast_mul_mem_zmultiples
 
 @[simp]
-theorem int_cast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R) :=
+theorem intCast_mem_zmultiples_one : ↑(k : ℤ) ∈ zmultiples (1 : R) :=
   mem_zmultiples_iff.mp ⟨k, by simp⟩
-#align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.int_cast_mem_zmultiples_one
+#align add_subgroup.int_cast_mem_zmultiples_one AddSubgroup.intCast_mem_zmultiples_one
 
 end Ring

chore: Rename zpow_coe_nat to zpow_natCast (#11528)

... and add a deprecated alias for the old name. This is mostly just me discovering the power of F2

75dad162

Diff

@@ -60,7 +60,7 @@ theorem zpow_mem_zpowers (g : G) (k : ℤ) : g ^ k ∈ zpowers g :=
 #align subgroup.zpow_mem_zpowers Subgroup.zpow_mem_zpowers
 
 theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
-  zpow_coe_nat g k ▸ zpow_mem_zpowers g k
+  zpow_natCast g k ▸ zpow_mem_zpowers g k
 #align subgroup.npow_mem_zpowers Subgroup.npow_mem_zpowers
 
 theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


# Loop through each file in the repository
for dir_path, dirs, files in os.walk('.'):
  for filename in files:
    if filename.endswith('.lean'):
      file_path = os.path.join(dir_path, filename)

      # Open the file and read its contents
      with open(file_path, 'r') as file:
        content = file.read()

      # Use a regular expression to replace sequences of "variable" lines separated by empty lines
      # with sequences without empty lines
      modified_content = re.sub(r'(variable.*\n)\n(variable(?! .* in))', r'\1\2', content)

      # Write the modified content back to the file
      with open(file_path, 'w') as file:
        file.write(modified_content)

75c86f04

Diff

@@ -20,9 +20,7 @@ subgroup, subgroups
 
 
 variable {G : Type*} [Group G]
-
 variable {A : Type*} [AddGroup A]
-
 variable {N : Type*} [Group N]
 
 namespace Subgroup

chore: Remove ball and bex from lemma names (#10816)

ball for "bounded forall" and bex for "bounded exists" are from experience very confusing abbreviations. This PR renames them to forall_mem and exists_mem in the few Set lemma names that mention them.

Also deprecate ball_image_of_ball, mem_image_elim, mem_image_elim_on since those lemmas are duplicates of the renamed lemmas (apart from argument order and implicitness, which I am also fixing by making the binder in the RHS of forall_mem_image semi-implicit), have obscure names and are completely unused.

c697e040

Diff

@@ -74,7 +74,7 @@ theorem exists_zpowers {x : G} {p : zpowers x → Prop} : (∃ g, p g) ↔ ∃ m
 #align subgroup.exists_zpowers Subgroup.exists_zpowers
 
 theorem forall_mem_zpowers {x : G} {p : G → Prop} : (∀ g ∈ zpowers x, p g) ↔ ∀ m : ℤ, p (x ^ m) :=
-  Set.forall_range_iff
+  Set.forall_mem_range
 #align subgroup.forall_mem_zpowers Subgroup.forall_mem_zpowers
 
 theorem exists_mem_zpowers {x : G} {p : G → Prop} : (∃ g ∈ zpowers x, p g) ↔ ∃ m : ℤ, p (x ^ m) :=

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -123,14 +123,14 @@ attribute [to_additive (attr := simp)] Subgroup.zpow_mem_zpowers
 attribute [to_additive (attr := simp)] Subgroup.npow_mem_zpowers
 #align add_subgroup.nsmul_mem_zmultiples AddSubgroup.nsmul_mem_zmultiples
 
---Porting note: increasing simp priority. Better lemma than `Subtype.forall`
+-- Porting note: increasing simp priority. Better lemma than `Subtype.forall`
 attribute [to_additive (attr := simp 1100)] Subgroup.forall_zpowers
 #align add_subgroup.forall_zmultiples AddSubgroup.forall_zmultiples
 
 attribute [to_additive] Subgroup.forall_mem_zpowers
 #align add_subgroup.forall_mem_zmultiples AddSubgroup.forall_mem_zmultiples
 
---Porting note: increasing simp priority. Better lemma than `Subtype.exists`
+-- Porting note: increasing simp priority. Better lemma than `Subtype.exists`
 attribute [to_additive (attr := simp 1100)] Subgroup.exists_zpowers
 #align add_subgroup.exists_zmultiples AddSubgroup.exists_zmultiples

add two to_additive name translations (#10831)

Remove manual translations that are now guessed correctly
Fix some names that were incorrectly guessed by humans (and in one case fix the multiplicative name). Add deprecations for all name changes.
Remove a couple manually additivized lemmas.

64848f61

Diff

@@ -98,43 +98,43 @@ theorem range_zmultiplesHom (a : A) : (zmultiplesHom A a).range = zmultiples a :
   rfl
 #align add_subgroup.range_zmultiples_hom AddSubgroup.range_zmultiplesHom
 
-attribute [to_additive existing AddSubgroup.zmultiples] Subgroup.zpowers
+attribute [to_additive existing] Subgroup.zpowers
 
-attribute [to_additive (attr := simp) AddSubgroup.mem_zmultiples] Subgroup.mem_zpowers
+attribute [to_additive (attr := simp)] Subgroup.mem_zpowers
 #align add_subgroup.mem_zmultiples AddSubgroup.mem_zmultiples
 
-attribute [to_additive (attr := norm_cast) AddSubgroup.coe_zmultiples] Subgroup.coe_zpowers
+attribute [to_additive (attr := norm_cast)] Subgroup.coe_zpowers
 
-attribute [to_additive AddSubgroup.decidableMemZMultiples] Subgroup.decidableMemZPowers
+attribute [to_additive] Subgroup.decidableMemZPowers
 #align decidable_zmultiples AddSubgroup.decidableMemZMultiples
 
-attribute [to_additive AddSubgroup.zmultiples_eq_closure] Subgroup.zpowers_eq_closure
+attribute [to_additive] Subgroup.zpowers_eq_closure
 #align add_subgroup.zmultiples_eq_closure AddSubgroup.zmultiples_eq_closure
 
-attribute [to_additive existing (attr := simp) AddSubgroup.range_zmultiplesHom]
+attribute [to_additive existing (attr := simp)]
   Subgroup.range_zpowersHom
 
-attribute [to_additive AddSubgroup.mem_zmultiples_iff] Subgroup.mem_zpowers_iff
+attribute [to_additive] Subgroup.mem_zpowers_iff
 #align add_subgroup.mem_zmultiples_iff AddSubgroup.mem_zmultiples_iff
 
-attribute [to_additive (attr := simp) AddSubgroup.zsmul_mem_zmultiples] Subgroup.zpow_mem_zpowers
+attribute [to_additive (attr := simp)] Subgroup.zpow_mem_zpowers
 #align add_subgroup.zsmul_mem_zmultiples AddSubgroup.zsmul_mem_zmultiples
 
-attribute [to_additive (attr := simp) AddSubgroup.nsmul_mem_zmultiples] Subgroup.npow_mem_zpowers
+attribute [to_additive (attr := simp)] Subgroup.npow_mem_zpowers
 #align add_subgroup.nsmul_mem_zmultiples AddSubgroup.nsmul_mem_zmultiples
 
 --Porting note: increasing simp priority. Better lemma than `Subtype.forall`
-attribute [to_additive (attr := simp 1100) AddSubgroup.forall_zmultiples] Subgroup.forall_zpowers
+attribute [to_additive (attr := simp 1100)] Subgroup.forall_zpowers
 #align add_subgroup.forall_zmultiples AddSubgroup.forall_zmultiples
 
-attribute [to_additive AddSubgroup.forall_mem_zmultiples] Subgroup.forall_mem_zpowers
+attribute [to_additive] Subgroup.forall_mem_zpowers
 #align add_subgroup.forall_mem_zmultiples AddSubgroup.forall_mem_zmultiples
 
 --Porting note: increasing simp priority. Better lemma than `Subtype.exists`
-attribute [to_additive (attr := simp 1100) AddSubgroup.exists_zmultiples] Subgroup.exists_zpowers
+attribute [to_additive (attr := simp 1100)] Subgroup.exists_zpowers
 #align add_subgroup.exists_zmultiples AddSubgroup.exists_zmultiples
 
-attribute [to_additive AddSubgroup.exists_mem_zmultiples] Subgroup.exists_mem_zpowers
+attribute [to_additive] Subgroup.exists_mem_zpowers
 #align add_subgroup.exists_mem_zmultiples AddSubgroup.exists_mem_zmultiples
 
 instance (a : A) : Countable (zmultiples a) :=
@@ -163,7 +163,7 @@ end AddSubgroup
   ext a
   simp_rw [AddMonoidHom.mem_range, Int.coe_castAddHom, AddSubgroup.mem_zmultiples_iff, zsmul_one]
 
-@[to_additive (attr := simp) map_zmultiples]
+@[to_additive (attr := simp)]
 theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
     (Subgroup.zpowers x).map f = Subgroup.zpowers (f x) := by
   rw [Subgroup.zpowers_eq_closure, Subgroup.zpowers_eq_closure, f.map_closure, Set.image_singleton]
@@ -204,7 +204,7 @@ namespace Subgroup
 
 variable {s : Set G} {g : G}
 
-@[to_additive zmultiples_isCommutative]
+@[to_additive]
 instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
   ⟨⟨fun ⟨_, _, h₁⟩ ⟨_, _, h₂⟩ => by
       rw [Subtype.ext_iff, coe_mul, coe_mul, Subtype.coe_mk, Subtype.coe_mk, ← h₁, ← h₂,
@@ -212,7 +212,7 @@ instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
 #align subgroup.zpowers_is_commutative Subgroup.zpowers_isCommutative
 #align add_subgroup.zmultiples_is_commutative AddSubgroup.zmultiples_isCommutative
 
-@[to_additive (attr := simp) zmultiples_le]
+@[to_additive (attr := simp)]
 theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
   rw [zpowers_eq_closure, closure_le, Set.singleton_subset_iff, SetLike.mem_coe]
 #align subgroup.zpowers_le Subgroup.zpowers_le
@@ -224,20 +224,20 @@ alias ⟨_, zpowers_le_of_mem⟩ := zpowers_le
 alias ⟨_, _root_.AddSubgroup.zmultiples_le_of_mem⟩ := AddSubgroup.zmultiples_le
 #align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_mem
 
-attribute [to_additive existing zmultiples_le_of_mem] zpowers_le_of_mem
+attribute [to_additive existing] zpowers_le_of_mem
 
-@[to_additive (attr := simp) zmultiples_eq_bot]
+@[to_additive (attr := simp)]
 theorem zpowers_eq_bot {g : G} : zpowers g = ⊥ ↔ g = 1 := by rw [eq_bot_iff, zpowers_le, mem_bot]
 #align subgroup.zpowers_eq_bot Subgroup.zpowers_eq_bot
 #align add_subgroup.zmultiples_eq_bot AddSubgroup.zmultiples_eq_bot
 
-@[to_additive zmultiples_ne_bot]
+@[to_additive]
 theorem zpowers_ne_bot : zpowers g ≠ ⊥ ↔ g ≠ 1 :=
   zpowers_eq_bot.not
 #align subgroup.zpowers_ne_bot Subgroup.zpowers_ne_bot
 #align add_subgroup.zmultiples_ne_bot AddSubgroup.zmultiples_ne_bot
 
-@[to_additive (attr := simp) zmultiples_zero_eq_bot]
+@[to_additive (attr := simp)]
 theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
   Subgroup.zpowers_eq_bot.mpr rfl
 #align subgroup.zpowers_one_eq_bot Subgroup.zpowers_one_eq_bot

fix: correct statement of zpow_ofNat and ofNat_zsmul (#10969)

Previously these were syntactically identical to the corresponding zpow_coe_nat and coe_nat_zsmul lemmas, now they are about OfNat.ofNat.

Unfortunately, almost every call site uses the ofNat name to refer to Nat.cast, so the downstream proofs had to be adjusted too.

d5525380

Diff

@@ -62,7 +62,7 @@ theorem zpow_mem_zpowers (g : G) (k : ℤ) : g ^ k ∈ zpowers g :=
 #align subgroup.zpow_mem_zpowers Subgroup.zpow_mem_zpowers
 
 theorem npow_mem_zpowers (g : G) (k : ℕ) : g ^ k ∈ zpowers g :=
-  zpow_ofNat g k ▸ zpow_mem_zpowers g k
+  zpow_coe_nat g k ▸ zpow_mem_zpowers g k
 #align subgroup.npow_mem_zpowers Subgroup.npow_mem_zpowers
 
 theorem forall_zpowers {x : G} {p : zpowers x → Prop} : (∀ g, p g) ↔ ∀ m : ℤ, p ⟨x ^ m, m, rfl⟩ :=

chore(*): shake imports (#10199)

Remove Data.Set.Basic from scripts/noshake.json.
Remove an exception that was used by examples only, move these examples to a new test file.
Drop an exception for Order.Filter.Basic dependency on Control.Traversable.Instances, as the relevant parts were moved to Order.Filter.ListTraverse.
Run lake exe shake --fix.

c167d468

Diff

@@ -6,6 +6,7 @@ Authors: Chris Hughes
 import Mathlib.GroupTheory.Subgroup.Basic
 import Mathlib.Data.Countable.Basic
 import Mathlib.Data.Set.Image
+import Mathlib.Data.Set.Basic
 
 #align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"

refactor: Delete Algebra.GroupPower.Lemmas (#9411)

Algebra.GroupPower.Lemmas used to be a big bag of lemmas that made it there on the criterion that they needed "more imports". This was completely untrue, as all lemmas could be moved to earlier files in PRs:

There are several reasons for this:

Necessary lemmas have been moved to earlier files since lemmas were dumped in Algebra.GroupPower.Lemmas
In the Lean 3 → Lean 4 transition, Std acquired basic Int and Nat lemmas which let us shortcircuit the part of the algebraic order hierarchy on which the corresponding general lemmas rest
Some proofs were overpowered
Some earlier files were tangled and I have untangled them

This PR finishes the job by moving the last few lemmas out of Algebra.GroupPower.Lemmas, which is therefore deleted.

6eb43dc3

Diff

@@ -3,7 +3,6 @@ Copyright (c) 2020 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
-import Mathlib.Algebra.GroupPower.Lemmas
 import Mathlib.GroupTheory.Subgroup.Basic
 import Mathlib.Data.Countable.Basic
 import Mathlib.Data.Set.Image

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

f4c4ca61

Diff

@@ -5,6 +5,8 @@ Authors: Chris Hughes
 -/
 import Mathlib.Algebra.GroupPower.Lemmas
 import Mathlib.GroupTheory.Subgroup.Basic
+import Mathlib.Data.Countable.Basic
+import Mathlib.Data.Set.Image
 
 #align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"

chore: Move order lemmas about zpow (#9805)

These lemmas can be proved earlier.

Part of #9411

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

91ac6909

Diff

@@ -3,6 +3,7 @@ Copyright (c) 2020 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 -/
+import Mathlib.Algebra.GroupPower.Lemmas
 import Mathlib.GroupTheory.Subgroup.Basic
 
 #align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"

chore: Nsmul -> NSMul, Zpow -> ZPow, etc (#9067)

Normalising to naming convention rule number 6.

9b2f0dca

Diff

@@ -37,9 +37,9 @@ theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range (g ^ · : ℤ → G) :=
   rfl
 #align subgroup.coe_zpowers Subgroup.coe_zpowers
 
-noncomputable instance decidableMemZpowers {a : G} : DecidablePred (· ∈ Subgroup.zpowers a) :=
+noncomputable instance decidableMemZPowers {a : G} : DecidablePred (· ∈ Subgroup.zpowers a) :=
   Classical.decPred _
-#align decidable_zpowers Subgroup.decidableMemZpowers
+#align decidable_zpowers Subgroup.decidableMemZPowers
 
 theorem zpowers_eq_closure (g : G) : zpowers g = closure {g} := by
   ext
@@ -102,8 +102,8 @@ attribute [to_additive (attr := simp) AddSubgroup.mem_zmultiples] Subgroup.mem_z
 
 attribute [to_additive (attr := norm_cast) AddSubgroup.coe_zmultiples] Subgroup.coe_zpowers
 
-attribute [to_additive AddSubgroup.decidableMemZmultiples] Subgroup.decidableMemZpowers
-#align decidable_zmultiples AddSubgroup.decidableMemZmultiples
+attribute [to_additive AddSubgroup.decidableMemZMultiples] Subgroup.decidableMemZPowers
+#align decidable_zmultiples AddSubgroup.decidableMemZMultiples
 
 attribute [to_additive AddSubgroup.zmultiples_eq_closure] Subgroup.zpowers_eq_closure
 #align add_subgroup.zmultiples_eq_closure AddSubgroup.zmultiples_eq_closure

feat: supporting lemmas for defining root systems (#8980)

A collection of loosely-related lemmas, split out from other work in the hopes of simplifying review.

e8acc5ce

Diff

@@ -171,6 +171,11 @@ theorem Int.mem_zmultiples_iff {a b : ℤ} : b ∈ AddSubgroup.zmultiples a ↔
   exists_congr fun k => by rw [mul_comm, eq_comm, ← smul_eq_mul]
 #align int.mem_zmultiples_iff Int.mem_zmultiples_iff
 
+@[simp]
+lemma Int.zmultiples_one : AddSubgroup.zmultiples (1 : ℤ) = ⊤ := by
+  ext z
+  simpa only [AddSubgroup.mem_top, iff_true] using ⟨z, zsmul_int_one z⟩
+
 theorem ofMul_image_zpowers_eq_zmultiples_ofMul {x : G} :
     Additive.ofMul '' (Subgroup.zpowers x : Set G) = AddSubgroup.zmultiples (Additive.ofMul x) := by
   ext y

chore: Replace (· op ·) a by (a op ·) (#8843)

I used the regex $\(· (.) ·$ (.)\), replacing with ($2 $1 ·).

d14658b4

Diff

@@ -26,7 +26,7 @@ namespace Subgroup
 
 /-- The subgroup generated by an element. -/
 def zpowers (g : G) : Subgroup G :=
-  Subgroup.copy (zpowersHom G g).range (Set.range ((· ^ ·) g : ℤ → G)) rfl
+  Subgroup.copy (zpowersHom G g).range (Set.range (g ^ · : ℤ → G)) rfl
 #align subgroup.zpowers Subgroup.zpowers
 
 theorem mem_zpowers (g : G) : g ∈ zpowers g :=

chore: Generalise lemmas from finite groups to torsion elements (#8342)

Many lemmas in GroupTheory.OrderOfElement were stated for elements of finite groups even though they work more generally for torsion elements of possibly infinite groups. This PR generalises those lemmas (and leaves convenience lemmas stated for finite groups), and fixes a bunch of names to use dot notation.

Renames

Function.eq_of_lt_minimalPeriod_of_iterate_eq → Function.iterate_injOn_Iio_minimalPeriod
Function.eq_iff_lt_minimalPeriod_of_iterate_eq → Function.iterate_eq_iterate_iff_of_lt_minimalPeriod
isOfFinOrder_iff_coe → Submonoid.isOfFinOrder_coe
orderOf_pos' → IsOfFinOrder.orderOf_pos
pow_eq_mod_orderOf → pow_mod_orderOf (and turned around)
pow_injective_of_lt_orderOf → pow_injOn_Iio_orderOf
mem_powers_iff_mem_range_order_of' → IsOfFinOrder.mem_powers_iff_mem_range_orderOf
orderOf_pow'' → IsOfFinOrder.orderOf_pow
orderOf_pow_coprime → Nat.Coprime.orderOf_pow
zpow_eq_mod_orderOf → zpow_mod_orderOf (and turned around)
exists_pow_eq_one → isOfFinOrder_of_finite
pow_apply_eq_pow_mod_orderOf_cycleOf_apply → pow_mod_orderOf_cycleOf_apply

New lemmas

IsOfFinOrder.powers_eq_image_range_orderOf
IsOfFinOrder.natCard_powers_le_orderOf
IsOfFinOrder.finite_powers
finite_powers
infinite_powers
Nat.card_submonoidPowers
IsOfFinOrder.mem_powers_iff_mem_zpowers
IsOfFinOrder.powers_eq_zpowers
IsOfFinOrder.mem_zpowers_iff_mem_range_orderOf
IsOfFinOrder.exists_pow_eq_one

Other changes

Move decidableMemPowers/fintypePowers to GroupTheory.Submonoid.Membership and decidableMemZpowers/fintypeZpowers to GroupTheory.Subgroup.ZPowers.
finEquivPowers, finEquivZpowers, powersEquivPowers and zpowersEquivZpowers now assume IsOfFinTorsion x instead of Finite G.
isOfFinOrder_iff_pow_eq_one now takes one less explicit argument.
Delete Equiv.Perm.IsCycle.exists_pow_eq_one since it was saying that a permutation over a finite type is torsion, but this is trivial since the group of permutation is itself finite, so we can use isOfFinOrder_of_finite instead.

771e087d

Diff

@@ -37,6 +37,10 @@ theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range (g ^ · : ℤ → G) :=
   rfl
 #align subgroup.coe_zpowers Subgroup.coe_zpowers
 
+noncomputable instance decidableMemZpowers {a : G} : DecidablePred (· ∈ Subgroup.zpowers a) :=
+  Classical.decPred _
+#align decidable_zpowers Subgroup.decidableMemZpowers
+
 theorem zpowers_eq_closure (g : G) : zpowers g = closure {g} := by
   ext
   exact mem_closure_singleton.symm
@@ -98,6 +102,9 @@ attribute [to_additive (attr := simp) AddSubgroup.mem_zmultiples] Subgroup.mem_z
 
 attribute [to_additive (attr := norm_cast) AddSubgroup.coe_zmultiples] Subgroup.coe_zpowers
 
+attribute [to_additive AddSubgroup.decidableMemZmultiples] Subgroup.decidableMemZpowers
+#align decidable_zmultiples AddSubgroup.decidableMemZmultiples
+
 attribute [to_additive AddSubgroup.zmultiples_eq_closure] Subgroup.zpowers_eq_closure
 #align add_subgroup.zmultiples_eq_closure AddSubgroup.zmultiples_eq_closure

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -203,10 +203,10 @@ theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
 #align subgroup.zpowers_le Subgroup.zpowers_le
 #align add_subgroup.zmultiples_le AddSubgroup.zmultiples_le
 
-alias zpowers_le ↔ _ zpowers_le_of_mem
+alias ⟨_, zpowers_le_of_mem⟩ := zpowers_le
 #align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_mem
 
-alias AddSubgroup.zmultiples_le ↔ _ _root_.AddSubgroup.zmultiples_le_of_mem
+alias ⟨_, _root_.AddSubgroup.zmultiples_le_of_mem⟩ := AddSubgroup.zmultiples_le
 #align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_mem
 
 attribute [to_additive existing zmultiples_le_of_mem] zpowers_le_of_mem

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

@@ -16,11 +16,11 @@ subgroup, subgroups
 -/
 
 
-variable {G : Type _} [Group G]
+variable {G : Type*} [Group G]
 
-variable {A : Type _} [AddGroup A]
+variable {A : Type*} [AddGroup A]
 
-variable {N : Type _} [Group N]
+variable {N : Type*} [Group N]
 
 namespace Subgroup
 
@@ -132,7 +132,7 @@ instance (a : A) : Countable (zmultiples a) :=
 
 section Ring
 
-variable {R : Type _} [Ring R] (r : R) (k : ℤ)
+variable {R : Type*} [Ring R] (r : R) (k : ℤ)
 
 @[simp]
 theorem int_cast_mul_mem_zmultiples : ↑(k : ℤ) * r ∈ zmultiples r := by
@@ -148,7 +148,7 @@ end Ring
 
 end AddSubgroup
 
-@[simp] lemma Int.range_castAddHom {A : Type _} [AddGroupWithOne A] :
+@[simp] lemma Int.range_castAddHom {A : Type*} [AddGroupWithOne A] :
     (Int.castAddHom A).range = AddSubgroup.zmultiples 1 := by
   ext a
   simp_rw [AddMonoidHom.mem_range, Int.coe_castAddHom, AddSubgroup.mem_zmultiples_iff, zsmul_one]

feat: basic facts about discrete subsets and subgroups (#5969)

Co-authored-by: Bhavik Mehta <bhavik.mehta8@gmail.com>

275b475d

Diff

@@ -148,6 +148,11 @@ end Ring
 
 end AddSubgroup
 
+@[simp] lemma Int.range_castAddHom {A : Type _} [AddGroupWithOne A] :
+    (Int.castAddHom A).range = AddSubgroup.zmultiples 1 := by
+  ext a
+  simp_rw [AddMonoidHom.mem_range, Int.coe_castAddHom, AddSubgroup.mem_zmultiples_iff, zsmul_one]
+
 @[to_additive (attr := simp) map_zmultiples]
 theorem MonoidHom.map_zpowers (f : G →* N) (x : G) :
     (Subgroup.zpowers x).map f = Subgroup.zpowers (f x) := by

chore(GroupTheory): forward-port leanprover-community/mathlib#18965 (#6147)

13e7c2f0

Diff

@@ -5,7 +5,7 @@ Authors: Chris Hughes
 -/
 import Mathlib.GroupTheory.Subgroup.Basic
 
-#align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
+#align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"4be589053caf347b899a494da75410deb55fb3ef"
 
 /-!
 # Subgroups generated by an element
@@ -225,7 +225,7 @@ theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
 
 @[to_additive]
 theorem centralizer_closure (S : Set G) :
-    (closure S).centralizer = ⨅ g ∈ S, (zpowers g).centralizer :=
+    centralizer (closure S : Set G) = ⨅ g ∈ S, centralizer (zpowers g : Set G) :=
   le_antisymm
       (le_iInf fun _ => le_iInf fun hg => centralizer_le <| zpowers_le.2 <| subset_closure hg) <|
     le_centralizer_iff.1 <|
@@ -237,7 +237,7 @@ theorem centralizer_closure (S : Set G) :
 @[to_additive]
 theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g ∈ S, centralizer (zpowers g) := by
-  rw [← centralizer_top, ← hS, centralizer_closure]
+  rw [← centralizer_univ, ← coe_top, ← hS, centralizer_closure]
 #align subgroup.center_eq_infi Subgroup.center_eq_iInf
 #align add_subgroup.center_eq_infi AddSubgroup.center_eq_iInf

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,14 +2,11 @@
 Copyright (c) 2020 Chris Hughes. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
-
-! This file was ported from Lean 3 source module group_theory.subgroup.zpowers
-! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.GroupTheory.Subgroup.Basic
 
+#align_import group_theory.subgroup.zpowers from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
+
 /-!
 # Subgroups generated by an element

chore: Rename to sSup/iSup (#3938)

As discussed on Zulip

Renames

supₛ → sSup
infₛ → sInf
supᵢ → iSup
infᵢ → iInf
bsupₛ → bsSup
binfₛ → bsInf
bsupᵢ → biSup
binfᵢ → biInf
csupₛ → csSup
cinfₛ → csInf
csupᵢ → ciSup
cinfᵢ → ciInf
unionₛ → sUnion
interₛ → sInter
unionᵢ → iUnion
interᵢ → iInter
bunionₛ → bsUnion
binterₛ → bsInter
bunionᵢ → biUnion
binterᵢ → biInter

Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

d1eb6264

Diff

@@ -230,24 +230,24 @@ theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
 theorem centralizer_closure (S : Set G) :
     (closure S).centralizer = ⨅ g ∈ S, (zpowers g).centralizer :=
   le_antisymm
-      (le_infᵢ fun _ => le_infᵢ fun hg => centralizer_le <| zpowers_le.2 <| subset_closure hg) <|
+      (le_iInf fun _ => le_iInf fun hg => centralizer_le <| zpowers_le.2 <| subset_closure hg) <|
     le_centralizer_iff.1 <|
       (closure_le _).2 fun g =>
-        SetLike.mem_coe.2 ∘ zpowers_le.1 ∘ le_centralizer_iff.1 ∘ infᵢ_le_of_le g ∘ infᵢ_le _
+        SetLike.mem_coe.2 ∘ zpowers_le.1 ∘ le_centralizer_iff.1 ∘ iInf_le_of_le g ∘ iInf_le _
 #align subgroup.centralizer_closure Subgroup.centralizer_closure
 #align add_subgroup.centralizer_closure AddSubgroup.centralizer_closure
 
 @[to_additive]
-theorem center_eq_infᵢ (S : Set G) (hS : closure S = ⊤) :
+theorem center_eq_iInf (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g ∈ S, centralizer (zpowers g) := by
   rw [← centralizer_top, ← hS, centralizer_closure]
-#align subgroup.center_eq_infi Subgroup.center_eq_infᵢ
-#align add_subgroup.center_eq_infi AddSubgroup.center_eq_infᵢ
+#align subgroup.center_eq_infi Subgroup.center_eq_iInf
+#align add_subgroup.center_eq_infi AddSubgroup.center_eq_iInf
 
 @[to_additive]
 theorem center_eq_infi' (S : Set G) (hS : closure S = ⊤) :
     center G = ⨅ g : S, centralizer (zpowers (g : G)) :=
-  by rw [center_eq_infᵢ S hS, ← infᵢ_subtype'']
+  by rw [center_eq_iInf S hS, ← iInf_subtype'']
 #align subgroup.center_eq_infi' Subgroup.center_eq_infi'
 #align add_subgroup.center_eq_infi' AddSubgroup.center_eq_infi'

https://github.com/leanprover-community/mathlib/pull/18668

feat: Induction principle for powers (#3278)

f8369997

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Chris Hughes
 
 ! This file was ported from Lean 3 source module group_theory.subgroup.zpowers
-! leanprover-community/mathlib commit f93c11933efbc3c2f0299e47b8ff83e9b539cbf6
+! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -36,6 +36,10 @@ theorem mem_zpowers (g : G) : g ∈ zpowers g :=
   ⟨1, zpow_one _⟩
 #align subgroup.mem_zpowers Subgroup.mem_zpowers
 
+theorem coe_zpowers (g : G) : ↑(zpowers g) = Set.range (g ^ · : ℤ → G) :=
+  rfl
+#align subgroup.coe_zpowers Subgroup.coe_zpowers
+
 theorem zpowers_eq_closure (g : G) : zpowers g = closure {g} := by
   ext
   exact mem_closure_singleton.symm
@@ -45,11 +49,6 @@ theorem range_zpowersHom (g : G) : (zpowersHom G g).range = zpowers g :=
   rfl
 #align subgroup.range_zpowers_hom Subgroup.range_zpowersHom
 
-theorem zpowers_subset {a : G} {K : Subgroup G} (h : a ∈ K) : zpowers a ≤ K := fun x hx =>
-  match x, hx with
-  | _, ⟨i, rfl⟩ => K.zpow_mem h i
-#align subgroup.zpowers_subset Subgroup.zpowers_subset
-
 theorem mem_zpowers_iff {g h : G} : h ∈ zpowers g ↔ ∃ k : ℤ, g ^ k = h :=
   Iff.rfl
 #align subgroup.mem_zpowers_iff Subgroup.mem_zpowers_iff
@@ -100,15 +99,14 @@ attribute [to_additive existing AddSubgroup.zmultiples] Subgroup.zpowers
 attribute [to_additive (attr := simp) AddSubgroup.mem_zmultiples] Subgroup.mem_zpowers
 #align add_subgroup.mem_zmultiples AddSubgroup.mem_zmultiples
 
+attribute [to_additive (attr := norm_cast) AddSubgroup.coe_zmultiples] Subgroup.coe_zpowers
+
 attribute [to_additive AddSubgroup.zmultiples_eq_closure] Subgroup.zpowers_eq_closure
 #align add_subgroup.zmultiples_eq_closure AddSubgroup.zmultiples_eq_closure
 
 attribute [to_additive existing (attr := simp) AddSubgroup.range_zmultiplesHom]
   Subgroup.range_zpowersHom
 
-attribute [to_additive AddSubgroup.zmultiples_subset] Subgroup.zpowers_subset
-#align add_subgroup.zmultiples_subset AddSubgroup.zmultiples_subset
-
 attribute [to_additive AddSubgroup.mem_zmultiples_iff] Subgroup.mem_zpowers_iff
 #align add_subgroup.mem_zmultiples_iff AddSubgroup.mem_zmultiples_iff
 
@@ -187,6 +185,8 @@ theorem ofAdd_image_zmultiples_eq_zpowers_ofAdd {x : A} :
 
 namespace Subgroup
 
+variable {s : Set G} {g : G}
+
 @[to_additive zmultiples_isCommutative]
 instance zpowers_isCommutative (g : G) : (zpowers g).IsCommutative :=
   ⟨⟨fun ⟨_, _, h₁⟩ ⟨_, _, h₂⟩ => by
@@ -201,11 +201,25 @@ theorem zpowers_le {g : G} {H : Subgroup G} : zpowers g ≤ H ↔ g ∈ H := by
 #align subgroup.zpowers_le Subgroup.zpowers_le
 #align add_subgroup.zmultiples_le AddSubgroup.zmultiples_le
 
+alias zpowers_le ↔ _ zpowers_le_of_mem
+#align subgroup.zpowers_le_of_mem Subgroup.zpowers_le_of_mem
+
+alias AddSubgroup.zmultiples_le ↔ _ _root_.AddSubgroup.zmultiples_le_of_mem
+#align add_subgroup.zmultiples_le_of_mem AddSubgroup.zmultiples_le_of_mem
+
+attribute [to_additive existing zmultiples_le_of_mem] zpowers_le_of_mem
+
 @[to_additive (attr := simp) zmultiples_eq_bot]
 theorem zpowers_eq_bot {g : G} : zpowers g = ⊥ ↔ g = 1 := by rw [eq_bot_iff, zpowers_le, mem_bot]
 #align subgroup.zpowers_eq_bot Subgroup.zpowers_eq_bot
 #align add_subgroup.zmultiples_eq_bot AddSubgroup.zmultiples_eq_bot
 
+@[to_additive zmultiples_ne_bot]
+theorem zpowers_ne_bot : zpowers g ≠ ⊥ ↔ g ≠ 1 :=
+  zpowers_eq_bot.not
+#align subgroup.zpowers_ne_bot Subgroup.zpowers_ne_bot
+#align add_subgroup.zmultiples_ne_bot AddSubgroup.zmultiples_ne_bot
+
 @[to_additive (attr := simp) zmultiples_zero_eq_bot]
 theorem zpowers_one_eq_bot : Subgroup.zpowers (1 : G) = ⊥ :=
   Subgroup.zpowers_eq_bot.mpr rfl

feat: add to_additive linter checking whether additive decl exists (#1881)

Force the user to specify whether the additive declaration already exists.
Will raise a linter error if the user specified it wrongly
Requested on Zulip

77e63150

Diff

@@ -95,7 +95,7 @@ theorem range_zmultiplesHom (a : A) : (zmultiplesHom A a).range = zmultiples a :
   rfl
 #align add_subgroup.range_zmultiples_hom AddSubgroup.range_zmultiplesHom
 
-attribute [to_additive AddSubgroup.zmultiples] Subgroup.zpowers
+attribute [to_additive existing AddSubgroup.zmultiples] Subgroup.zpowers
 
 attribute [to_additive (attr := simp) AddSubgroup.mem_zmultiples] Subgroup.mem_zpowers
 #align add_subgroup.mem_zmultiples AddSubgroup.mem_zmultiples
@@ -103,7 +103,8 @@ attribute [to_additive (attr := simp) AddSubgroup.mem_zmultiples] Subgroup.mem_z
 attribute [to_additive AddSubgroup.zmultiples_eq_closure] Subgroup.zpowers_eq_closure
 #align add_subgroup.zmultiples_eq_closure AddSubgroup.zmultiples_eq_closure
 
-attribute [to_additive (attr := simp) AddSubgroup.range_zmultiplesHom] Subgroup.range_zpowersHom
+attribute [to_additive existing (attr := simp) AddSubgroup.range_zmultiplesHom]
+  Subgroup.range_zpowersHom
 
 attribute [to_additive AddSubgroup.zmultiples_subset] Subgroup.zpowers_subset
 #align add_subgroup.zmultiples_subset AddSubgroup.zmultiples_subset

chore: add missing #align statements (#1902)

This PR is the result of a slight variant on the following "algorithm"

take all mathlib 3 names, remove _ and make all uppercase letters into lowercase
take all mathlib 4 names, remove _ and make all uppercase letters into lowercase
look for matches, and create pairs (original_lean3_name, OriginalLean4Name)
for pairs that do not have an align statement:
- use Lean 4 to lookup the file + position of the Lean 4 name
- add an #align statement just before the next empty line
manually fix some tiny mistakes (e.g., empty lines in proofs might cause the #align statement to have been inserted too early)

b72bb858

Diff

@@ -98,28 +98,38 @@ theorem range_zmultiplesHom (a : A) : (zmultiplesHom A a).range = zmultiples a :
 attribute [to_additive AddSubgroup.zmultiples] Subgroup.zpowers
 
 attribute [to_additive (attr := simp) AddSubgroup.mem_zmultiples] Subgroup.mem_zpowers
+#align add_subgroup.mem_zmultiples AddSubgroup.mem_zmultiples
 
 attribute [to_additive AddSubgroup.zmultiples_eq_closure] Subgroup.zpowers_eq_closure
+#align add_subgroup.zmultiples_eq_closure AddSubgroup.zmultiples_eq_closure
 
 attribute [to_additive (attr := simp) AddSubgroup.range_zmultiplesHom] Subgroup.range_zpowersHom
 
 attribute [to_additive AddSubgroup.zmultiples_subset] Subgroup.zpowers_subset
+#align add_subgroup.zmultiples_subset AddSubgroup.zmultiples_subset
 
 attribute [to_additive AddSubgroup.mem_zmultiples_iff] Subgroup.mem_zpowers_iff
+#align add_subgroup.mem_zmultiples_iff AddSubgroup.mem_zmultiples_iff
 
 attribute [to_additive (attr := simp) AddSubgroup.zsmul_mem_zmultiples] Subgroup.zpow_mem_zpowers
+#align add_subgroup.zsmul_mem_zmultiples AddSubgroup.zsmul_mem_zmultiples
 
 attribute [to_additive (attr := simp) AddSubgroup.nsmul_mem_zmultiples] Subgroup.npow_mem_zpowers
+#align add_subgroup.nsmul_mem_zmultiples AddSubgroup.nsmul_mem_zmultiples
 
 --Porting note: increasing simp priority. Better lemma than `Subtype.forall`
 attribute [to_additive (attr := simp 1100) AddSubgroup.forall_zmultiples] Subgroup.forall_zpowers
+#align add_subgroup.forall_zmultiples AddSubgroup.forall_zmultiples
 
 attribute [to_additive AddSubgroup.forall_mem_zmultiples] Subgroup.forall_mem_zpowers
+#align add_subgroup.forall_mem_zmultiples AddSubgroup.forall_mem_zmultiples
 
 --Porting note: increasing simp priority. Better lemma than `Subtype.exists`
 attribute [to_additive (attr := simp 1100) AddSubgroup.exists_zmultiples] Subgroup.exists_zpowers
+#align add_subgroup.exists_zmultiples AddSubgroup.exists_zmultiples
 
 attribute [to_additive AddSubgroup.exists_mem_zmultiples] Subgroup.exists_mem_zpowers
+#align add_subgroup.exists_mem_zmultiples AddSubgroup.exists_mem_zmultiples
 
 instance (a : A) : Countable (zmultiples a) :=
   (zmultiplesHom A a).rangeRestrict_surjective.countable