deprecated.subgroup ⟷ Mathlib.Deprecated.Subgroup

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

@@ -263,7 +263,7 @@ variable [Group G]
 theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a * b ∈ s) :
     b * a ∈ s := by
   have h : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ s := hs.Normal (a * b) hab a⁻¹
-  simp at h  <;> exact h
+  simp at h <;> exact h
 #align is_subgroup.mem_norm_comm IsSubgroup.mem_norm_comm
 #align is_add_subgroup.mem_norm_comm IsAddSubgroup.mem_norm_comm
 -/
@@ -415,7 +415,7 @@ variable [Group G] [Group H]
 @[to_additive]
 theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) : f a = f b :=
   by
-  rw [hf.map_mul, hf.map_inv] at h 
+  rw [hf.map_mul, hf.map_inv] at h
   rw [← inv_inv (f b), eq_inv_of_mul_eq_one_left h]
 #align is_group_hom.one_ker_inv IsGroupHom.one_ker_inv
 #align is_add_group_hom.zero_ker_neg IsAddGroupHom.zero_ker_neg
@@ -425,7 +425,7 @@ theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻
 @[to_additive]
 theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) : f a = f b :=
   by
-  rw [hf.map_mul, hf.map_inv] at h 
+  rw [hf.map_mul, hf.map_inv] at h
   apply inv_injective
   rw [eq_inv_of_mul_eq_one_left h]
 #align is_group_hom.one_ker_inv' IsGroupHom.one_ker_inv'
@@ -437,7 +437,7 @@ theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹
 theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a * b⁻¹) = 1 :=
   by
   have : f a * (f b)⁻¹ = 1 := by rw [h, mul_right_inv]
-  rwa [← hf.map_inv, ← hf.map_mul] at this 
+  rwa [← hf.map_inv, ← hf.map_mul] at this
 #align is_group_hom.inv_ker_one IsGroupHom.inv_ker_one
 #align is_add_group_hom.neg_ker_zero IsAddGroupHom.neg_ker_zero
 -/
@@ -447,7 +447,7 @@ theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b)
 theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a⁻¹ * b) = 1 :=
   by
   have : (f a)⁻¹ * f b = 1 := by rw [h, mul_left_inv]
-  rwa [← hf.map_inv, ← hf.map_mul] at this 
+  rwa [← hf.map_inv, ← hf.map_mul] at this
 #align is_group_hom.inv_ker_one' IsGroupHom.inv_ker_one'
 #align is_add_group_hom.neg_ker_zero' IsAddGroupHom.neg_ker_zero'
 -/
@@ -542,7 +542,7 @@ theorem isNormalSubgroup_ker {f : G → H} (hf : IsGroupHom f) : IsNormalSubgrou
 theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f = trivial G) :
     Function.Injective f := by
   intro a₁ a₂ hfa
-  simp [ext_iff, ker, IsSubgroup.trivial] at h 
+  simp [ext_iff, ker, IsSubgroup.trivial] at h
   have ha : a₁ * a₂⁻¹ = 1 := by rw [← h] <;> exact hf.inv_ker_one hfa
   rw [eq_inv_of_mul_eq_one_left ha, inv_inv a₂]
 #align is_group_hom.injective_of_trivial_ker IsGroupHom.injective_of_trivial_ker
@@ -557,7 +557,7 @@ theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function
     Iff.intro
       (fun hx => by
         suffices f x = f 1 by simpa using h this
-        simp [hf.map_one] <;> rwa [mem_ker] at hx )
+        simp [hf.map_one] <;> rwa [mem_ker] at hx)
       (by simp (config := { contextual := true }) [mem_ker, hf.map_one])
 #align is_group_hom.trivial_ker_of_injective IsGroupHom.trivial_ker_of_injective
 #align is_add_group_hom.trivial_ker_of_injective IsAddGroupHom.trivial_ker_of_injective

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

@@ -4,8 +4,8 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mitchell Rowett, Scott Morrison, Johan Commelin, Mario Carneiro,
   Michael Howes
 -/
-import Mathbin.GroupTheory.Subgroup.Basic
-import Mathbin.Deprecated.Submonoid
+import GroupTheory.Subgroup.Basic
+import Deprecated.Submonoid
 
 #align_import deprecated.subgroup from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
 

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

@@ -105,7 +105,7 @@ theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
     have : 1 * a⁻¹ ∈ s := div_mem one_mem ha
     simpa
   { inv_mem
-    mul_mem := fun a b ha hb =>
+    hMul_mem := fun a b ha hb =>
       by
       have : a * b⁻¹⁻¹ ∈ s := div_mem ha (inv_mem b hb)
       simpa
@@ -175,7 +175,7 @@ theorem inv_mem_iff : a⁻¹ ∈ s ↔ a ∈ s :=
 #print IsSubgroup.mul_mem_cancel_right /-
 @[to_additive]
 theorem mul_mem_cancel_right (h : a ∈ s) : b * a ∈ s ↔ b ∈ s :=
-  ⟨fun hba => by simpa using hs.mul_mem hba (hs.inv_mem h), fun hb => hs.mul_mem hb h⟩
+  ⟨fun hba => by simpa using hs.mul_mem hba (hs.inv_mem h), fun hb => hs.hMul_mem hb h⟩
 #align is_subgroup.mul_mem_cancel_right IsSubgroup.mul_mem_cancel_right
 #align is_add_subgroup.add_mem_cancel_right IsAddSubgroup.add_mem_cancel_right
 -/
@@ -183,7 +183,7 @@ theorem mul_mem_cancel_right (h : a ∈ s) : b * a ∈ s ↔ b ∈ s :=
 #print IsSubgroup.mul_mem_cancel_left /-
 @[to_additive]
 theorem mul_mem_cancel_left (h : a ∈ s) : a * b ∈ s ↔ b ∈ s :=
-  ⟨fun hab => by simpa using hs.mul_mem (hs.inv_mem h) hab, hs.mul_mem h⟩
+  ⟨fun hab => by simpa using hs.mul_mem (hs.inv_mem h) hab, hs.hMul_mem h⟩
 #align is_subgroup.mul_mem_cancel_left IsSubgroup.mul_mem_cancel_left
 #align is_add_subgroup.add_mem_cancel_left IsAddSubgroup.add_mem_cancel_left
 -/
@@ -338,7 +338,7 @@ theorem mem_center {a : G} : a ∈ center G ↔ ∀ g, g * a = a * g :=
 @[to_additive add_center_normal]
 theorem center_normal : IsNormalSubgroup (center G) :=
   { one_mem := by simp [center]
-    mul_mem := fun a b ha hb g => by
+    hMul_mem := fun a b ha hb g => by
       rw [← mul_assoc, mem_center.2 ha g, mul_assoc, mem_center.2 hb g, ← mul_assoc]
     inv_mem := fun a ha g =>
       calc
@@ -368,7 +368,7 @@ def normalizer (s : Set G) : Set G :=
 @[to_additive]
 theorem normalizer_isSubgroup (s : Set G) : IsSubgroup (normalizer s) :=
   { one_mem := by simp [normalizer]
-    mul_mem := fun a b (ha : ∀ n, n ∈ s ↔ a * n * a⁻¹ ∈ s) (hb : ∀ n, n ∈ s ↔ b * n * b⁻¹ ∈ s) n =>
+    hMul_mem := fun a b (ha : ∀ n, n ∈ s ↔ a * n * a⁻¹ ∈ s) (hb : ∀ n, n ∈ s ↔ b * n * b⁻¹ ∈ s) n =>
       by rw [mul_inv_rev, ← mul_assoc, mul_assoc a, mul_assoc a, ← ha, ← hb]
     inv_mem := fun a (ha : ∀ n, n ∈ s ↔ a * n * a⁻¹ ∈ s) n => by
       rw [ha (a⁻¹ * n * a⁻¹⁻¹)] <;> simp [mul_assoc] }
@@ -488,8 +488,8 @@ theorem inv_iff_ker' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔
 @[to_additive]
 theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSubgroup s) :
     IsSubgroup (f '' s) :=
-  { mul_mem := fun a₁ a₂ ⟨b₁, hb₁, eq₁⟩ ⟨b₂, hb₂, eq₂⟩ =>
-      ⟨b₁ * b₂, hs.mul_mem hb₁ hb₂, by simp [eq₁, eq₂, hf.map_mul]⟩
+  { hMul_mem := fun a₁ a₂ ⟨b₁, hb₁, eq₁⟩ ⟨b₂, hb₂, eq₂⟩ =>
+      ⟨b₁ * b₂, hs.hMul_mem hb₁ hb₂, by simp [eq₁, eq₂, hf.map_mul]⟩
     one_mem := ⟨1, hs.to_isSubmonoid.one_mem, hf.map_one⟩
     inv_mem := fun a ⟨b, hb, Eq⟩ => ⟨b⁻¹, hs.inv_mem hb, by rw [hf.map_inv]; simp [*]⟩ }
 #align is_group_hom.image_subgroup IsGroupHom.image_subgroup
@@ -522,7 +522,7 @@ theorem preimage {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsSubgroup
 theorem preimage_normal {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsNormalSubgroup s) :
     IsNormalSubgroup (f ⁻¹' s) :=
   { one_mem := by simp [hf.map_one, hs.to_is_subgroup.one_mem]
-    mul_mem := by simp (config := { contextual := true }) [hf.map_mul, hs.to_is_subgroup.mul_mem]
+    hMul_mem := by simp (config := { contextual := true }) [hf.map_mul, hs.to_is_subgroup.mul_mem]
     inv_mem := by simp (config := { contextual := true }) [hf.map_inv, hs.to_is_subgroup.inv_mem]
     Normal := by simp (config := { contextual := true }) [hs.normal, hf.map_mul, hf.map_inv] }
 #align is_group_hom.preimage_normal IsGroupHom.preimage_normal
@@ -642,7 +642,7 @@ theorem mem_closure {a : G} : a ∈ s → a ∈ closure s :=
 @[to_additive]
 theorem closure.isSubgroup (s : Set G) : IsSubgroup (closure s) :=
   { one_mem := InClosure.one
-    mul_mem := fun a b => InClosure.mul
+    hMul_mem := fun a b => InClosure.mul
     inv_mem := fun a => InClosure.inv }
 #align group.closure.is_subgroup Group.closure.isSubgroup
 #align add_group.closure.is_add_subgroup AddGroup.closure.isAddSubgroup
@@ -721,7 +721,7 @@ theorem image_closure [Group H] {f : G → H} (hf : IsGroupHom f) (s : Set G) :
       · rw [hf.map_inv]
         apply IsSubgroup.inv_mem (closure.is_subgroup _); assumption
       · rw [hf.to_is_monoid_hom.map_mul]
-        solve_by_elim [IsSubmonoid.mul_mem (closure.is_subgroup _).to_isSubmonoid])
+        solve_by_elim [IsSubmonoid.hMul_mem (closure.is_subgroup _).to_isSubmonoid])
     (closure_subset (hf.image_subgroup <| closure.isSubgroup _) <|
       Set.image_subset _ subset_closure)
 #align group.image_closure Group.image_closure
@@ -751,7 +751,7 @@ theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.
   Set.Subset.antisymm
     (@closure_subset _ _ _ (Monoid.Closure (s ∪ Inv.inv ⁻¹' s))
       { one_mem := (Monoid.closure.isSubmonoid _).one_mem
-        mul_mem := fun _ _ => (Monoid.closure.isSubmonoid _).mul_mem
+        hMul_mem := fun _ _ => (Monoid.closure.isSubmonoid _).hMul_mem
         inv_mem := fun x hx =>
           Monoid.InClosure.rec_on hx
             (fun x hx =>
@@ -761,7 +761,7 @@ theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.
                 fun hx => Monoid.subset_closure <| Or.inl hx)
             ((@inv_one G _).symm ▸ IsSubmonoid.one_mem (Monoid.closure.isSubmonoid _))
             fun x y hx hy ihx ihy =>
-            (mul_inv_rev x y).symm ▸ IsSubmonoid.mul_mem (Monoid.closure.isSubmonoid _) ihy ihx }
+            (mul_inv_rev x y).symm ▸ IsSubmonoid.hMul_mem (Monoid.closure.isSubmonoid _) ihy ihx }
       (Set.Subset.trans (Set.subset_union_left _ _) Monoid.subset_closure))
     (Monoid.closure_subset (closure.isSubgroup _).to_isSubmonoid <|
       Set.union_subset subset_closure fun x hx =>
@@ -865,7 +865,7 @@ theorem normalClosure.is_normal : IsNormalSubgroup (normalClosure s) :=
       · rw [← conj_inv]
         exact (normal_closure.is_subgroup _).inv_mem ihx
       · rw [← conj_mul]
-        exact (normal_closure.is_subgroup _).to_isSubmonoid.mul_mem ihx ihy }
+        exact (normal_closure.is_subgroup _).to_isSubmonoid.hMul_mem ihx ihy }
 #align group.normal_closure.is_normal Group.normalClosure.is_normal
 -/
 
@@ -904,7 +904,7 @@ def Subgroup.of [Group G] {s : Set G} (h : IsSubgroup s) : Subgroup G
     where
   carrier := s
   one_mem' := h.1.1
-  mul_mem' _ _ := h.1.2
+  hMul_mem' _ _ := h.1.2
   inv_mem' _ := h.2
 #align subgroup.of Subgroup.of
 #align add_subgroup.of AddSubgroup.of
@@ -914,7 +914,7 @@ def Subgroup.of [Group G] {s : Set G} (h : IsSubgroup s) : Subgroup G
 @[to_additive]
 theorem Subgroup.isSubgroup [Group G] (K : Subgroup G) : IsSubgroup (K : Set G) :=
   { one_mem := K.one_mem'
-    mul_mem := fun _ _ => K.mul_mem'
+    hMul_mem := fun _ _ => K.hMul_mem'
     inv_mem := fun _ => K.inv_mem' }
 #align subgroup.is_subgroup Subgroup.isSubgroup
 #align add_subgroup.is_add_subgroup AddSubgroup.isAddSubgroup

mathlib commit https://github.com/leanprover-community/mathlib/commit/63721b2c3eba6c325ecf8ae8cca27155a4f6306f

@@ -696,7 +696,7 @@ theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
     (fun x _ ⟨L, HL1, HL2⟩ =>
       ⟨L.reverse.map Inv.inv, fun x hx =>
         let ⟨y, hy1, hy2⟩ := List.exists_of_mem_map hx
-        hy2 ▸ Or.imp id (by rw [inv_inv] <;> exact id) (HL1 _ <| List.mem_reverse'.1 hy1).symm,
+        hy2 ▸ Or.imp id (by rw [inv_inv] <;> exact id) (HL1 _ <| List.mem_reverse.1 hy1).symm,
         HL2 ▸
           List.recOn L inv_one.symm fun hd tl ih => by
             rw [List.reverse_cons, List.map_append, List.prod_append, ih, List.map_singleton,

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

@@ -3,15 +3,12 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mitchell Rowett, Scott Morrison, Johan Commelin, Mario Carneiro,
   Michael Howes
-
-! This file was ported from Lean 3 source module deprecated.subgroup
-! leanprover-community/mathlib commit fac369018417f980cec5fcdafc766a69f88d8cfe
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.GroupTheory.Subgroup.Basic
 import Mathbin.Deprecated.Submonoid
 
+#align_import deprecated.subgroup from "leanprover-community/mathlib"@"fac369018417f980cec5fcdafc766a69f88d8cfe"
+
 /-!
 # Unbundled subgroups (deprecated)
 

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

@@ -62,11 +62,13 @@ structure IsSubgroup (s : Set G) extends IsSubmonoid s : Prop where
 #align is_add_subgroup IsAddSubgroup
 -/
 
+#print IsSubgroup.div_mem /-
 @[to_additive]
 theorem IsSubgroup.div_mem {s : Set G} (hs : IsSubgroup s) {x y : G} (hx : x ∈ s) (hy : y ∈ s) :
     x / y ∈ s := by simpa only [div_eq_mul_inv] using hs.mul_mem hx (hs.inv_mem hy)
 #align is_subgroup.div_mem IsSubgroup.div_mem
 #align is_add_subgroup.sub_mem IsAddSubgroup.sub_mem
+-/
 
 #print Additive.isAddSubgroup /-
 theorem Additive.isAddSubgroup {s : Set G} (hs : IsSubgroup s) : @IsAddSubgroup (Additive G) _ s :=
@@ -97,6 +99,7 @@ theorem Multiplicative.isSubgroup_iff {s : Set A} :
 #align multiplicative.is_subgroup_iff Multiplicative.isSubgroup_iff
 -/
 
+#print IsSubgroup.of_div /-
 @[to_additive ofAdd_neg]
 theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
     (div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s) : IsSubgroup s :=
@@ -112,13 +115,17 @@ theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
     one_mem }
 #align is_subgroup.of_div IsSubgroup.of_div
 #align is_add_subgroup.of_add_neg IsAddSubgroup.of_add_neg
+-/
 
+#print IsAddSubgroup.of_sub /-
 theorem IsAddSubgroup.of_sub (s : Set A) (zero_mem : (0 : A) ∈ s)
     (sub_mem : ∀ {a b : A}, a ∈ s → b ∈ s → a - b ∈ s) : IsAddSubgroup s :=
   IsAddSubgroup.of_add_neg s zero_mem fun x y hx hy => by
     simpa only [sub_eq_add_neg] using sub_mem hx hy
 #align is_add_subgroup.of_sub IsAddSubgroup.of_sub
+-/
 
+#print IsSubgroup.inter /-
 @[to_additive]
 theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ : IsSubgroup s₂) :
     IsSubgroup (s₁ ∩ s₂) :=
@@ -126,6 +133,7 @@ theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ :
     inv_mem := fun x hx => ⟨hs₁.inv_mem hx.1, hs₂.inv_mem hx.2⟩ }
 #align is_subgroup.inter IsSubgroup.inter
 #align is_add_subgroup.inter IsAddSubgroup.inter
+-/
 
 #print IsSubgroup.iInter /-
 @[to_additive]
@@ -159,25 +167,29 @@ open IsSubmonoid
 
 variable [Group G] {s : Set G} (hs : IsSubgroup s)
 
-include hs
-
+#print IsSubgroup.inv_mem_iff /-
 @[to_additive]
 theorem inv_mem_iff : a⁻¹ ∈ s ↔ a ∈ s :=
   ⟨fun h => by simpa using hs.inv_mem h, inv_mem hs⟩
 #align is_subgroup.inv_mem_iff IsSubgroup.inv_mem_iff
 #align is_add_subgroup.neg_mem_iff IsAddSubgroup.neg_mem_iff
+-/
 
+#print IsSubgroup.mul_mem_cancel_right /-
 @[to_additive]
 theorem mul_mem_cancel_right (h : a ∈ s) : b * a ∈ s ↔ b ∈ s :=
   ⟨fun hba => by simpa using hs.mul_mem hba (hs.inv_mem h), fun hb => hs.mul_mem hb h⟩
 #align is_subgroup.mul_mem_cancel_right IsSubgroup.mul_mem_cancel_right
 #align is_add_subgroup.add_mem_cancel_right IsAddSubgroup.add_mem_cancel_right
+-/
 
+#print IsSubgroup.mul_mem_cancel_left /-
 @[to_additive]
 theorem mul_mem_cancel_left (h : a ∈ s) : a * b ∈ s ↔ b ∈ s :=
   ⟨fun hab => by simpa using hs.mul_mem (hs.inv_mem h) hab, hs.mul_mem h⟩
 #align is_subgroup.mul_mem_cancel_left IsSubgroup.mul_mem_cancel_left
 #align is_add_subgroup.add_mem_cancel_left IsAddSubgroup.add_mem_cancel_left
+-/
 
 end IsSubgroup
 
@@ -248,6 +260,7 @@ namespace IsSubgroup
 
 variable [Group G]
 
+#print IsSubgroup.mem_norm_comm /-
 -- Normal subgroup properties
 @[to_additive]
 theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a * b ∈ s) :
@@ -256,12 +269,15 @@ theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a *
   simp at h  <;> exact h
 #align is_subgroup.mem_norm_comm IsSubgroup.mem_norm_comm
 #align is_add_subgroup.mem_norm_comm IsAddSubgroup.mem_norm_comm
+-/
 
+#print IsSubgroup.mem_norm_comm_iff /-
 @[to_additive]
 theorem mem_norm_comm_iff {s : Set G} (hs : IsNormalSubgroup s) {a b : G} : a * b ∈ s ↔ b * a ∈ s :=
   ⟨mem_norm_comm hs, mem_norm_comm hs⟩
 #align is_subgroup.mem_norm_comm_iff IsSubgroup.mem_norm_comm_iff
 #align is_add_subgroup.mem_norm_comm_iff IsAddSubgroup.mem_norm_comm_iff
+-/
 
 #print IsSubgroup.trivial /-
 /-- The trivial subgroup -/
@@ -272,11 +288,13 @@ def trivial (G : Type _) [Group G] : Set G :=
 #align is_add_subgroup.trivial IsAddSubgroup.trivial
 -/
 
+#print IsSubgroup.mem_trivial /-
 @[simp, to_additive]
 theorem mem_trivial {g : G} : g ∈ trivial G ↔ g = 1 :=
   mem_singleton_iff
 #align is_subgroup.mem_trivial IsSubgroup.mem_trivial
 #align is_add_subgroup.mem_trivial IsAddSubgroup.mem_trivial
+-/
 
 #print IsSubgroup.trivial_normal /-
 @[to_additive]
@@ -286,12 +304,14 @@ theorem trivial_normal : IsNormalSubgroup (trivial G) := by
 #align is_add_subgroup.trivial_normal IsAddSubgroup.trivial_normal
 -/
 
+#print IsSubgroup.eq_trivial_iff /-
 @[to_additive]
 theorem eq_trivial_iff {s : Set G} (hs : IsSubgroup s) : s = trivial G ↔ ∀ x ∈ s, x = (1 : G) := by
   simp only [Set.ext_iff, IsSubgroup.mem_trivial] <;>
     exact ⟨fun h x => (h x).1, fun h x => ⟨h x, fun hx => hx.symm ▸ hs.to_is_submonoid.one_mem⟩⟩
 #align is_subgroup.eq_trivial_iff IsSubgroup.eq_trivial_iff
 #align is_add_subgroup.eq_trivial_iff IsAddSubgroup.eq_trivial_iff
+-/
 
 #print IsSubgroup.univ_subgroup /-
 @[to_additive]
@@ -309,11 +329,13 @@ def center (G : Type _) [Group G] : Set G :=
 #align is_add_subgroup.add_center IsAddSubgroup.addCenter
 -/
 
+#print IsSubgroup.mem_center /-
 @[to_additive mem_add_center]
 theorem mem_center {a : G} : a ∈ center G ↔ ∀ g, g * a = a * g :=
   Iff.rfl
 #align is_subgroup.mem_center IsSubgroup.mem_center
 #align is_add_subgroup.mem_add_center IsAddSubgroup.mem_add_center
+-/
 
 #print IsSubgroup.center_normal /-
 @[to_additive add_center_normal]
@@ -382,14 +404,17 @@ def ker [Group H] (f : G → H) : Set G :=
 #align is_add_group_hom.ker IsAddGroupHom.ker
 -/
 
+#print IsGroupHom.mem_ker /-
 @[to_additive]
 theorem mem_ker [Group H] (f : G → H) {x : G} : x ∈ ker f ↔ f x = 1 :=
   mem_trivial
 #align is_group_hom.mem_ker IsGroupHom.mem_ker
 #align is_add_group_hom.mem_ker IsAddGroupHom.mem_ker
+-/
 
 variable [Group G] [Group H]
 
+#print IsGroupHom.one_ker_inv /-
 @[to_additive]
 theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) : f a = f b :=
   by
@@ -397,7 +422,9 @@ theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻
   rw [← inv_inv (f b), eq_inv_of_mul_eq_one_left h]
 #align is_group_hom.one_ker_inv IsGroupHom.one_ker_inv
 #align is_add_group_hom.zero_ker_neg IsAddGroupHom.zero_ker_neg
+-/
 
+#print IsGroupHom.one_ker_inv' /-
 @[to_additive]
 theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) : f a = f b :=
   by
@@ -406,7 +433,9 @@ theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹
   rw [eq_inv_of_mul_eq_one_left h]
 #align is_group_hom.one_ker_inv' IsGroupHom.one_ker_inv'
 #align is_add_group_hom.zero_ker_neg' IsAddGroupHom.zero_ker_neg'
+-/
 
+#print IsGroupHom.inv_ker_one /-
 @[to_additive]
 theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a * b⁻¹) = 1 :=
   by
@@ -414,7 +443,9 @@ theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b)
   rwa [← hf.map_inv, ← hf.map_mul] at this 
 #align is_group_hom.inv_ker_one IsGroupHom.inv_ker_one
 #align is_add_group_hom.neg_ker_zero IsAddGroupHom.neg_ker_zero
+-/
 
+#print IsGroupHom.inv_ker_one' /-
 @[to_additive]
 theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a⁻¹ * b) = 1 :=
   by
@@ -422,31 +453,41 @@ theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b)
   rwa [← hf.map_inv, ← hf.map_mul] at this 
 #align is_group_hom.inv_ker_one' IsGroupHom.inv_ker_one'
 #align is_add_group_hom.neg_ker_zero' IsAddGroupHom.neg_ker_zero'
+-/
 
+#print IsGroupHom.one_iff_ker_inv /-
 @[to_additive]
 theorem one_iff_ker_inv {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a * b⁻¹) = 1 :=
   ⟨hf.inv_ker_one, hf.one_ker_inv⟩
 #align is_group_hom.one_iff_ker_inv IsGroupHom.one_iff_ker_inv
 #align is_add_group_hom.zero_iff_ker_neg IsAddGroupHom.zero_iff_ker_neg
+-/
 
+#print IsGroupHom.one_iff_ker_inv' /-
 @[to_additive]
 theorem one_iff_ker_inv' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a⁻¹ * b) = 1 :=
   ⟨hf.inv_ker_one', hf.one_ker_inv'⟩
 #align is_group_hom.one_iff_ker_inv' IsGroupHom.one_iff_ker_inv'
 #align is_add_group_hom.zero_iff_ker_neg' IsAddGroupHom.zero_iff_ker_neg'
+-/
 
+#print IsGroupHom.inv_iff_ker /-
 @[to_additive]
 theorem inv_iff_ker {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a * b⁻¹ ∈ ker f := by
   rw [mem_ker] <;> exact one_iff_ker_inv hf _ _
 #align is_group_hom.inv_iff_ker IsGroupHom.inv_iff_ker
 #align is_add_group_hom.neg_iff_ker IsAddGroupHom.neg_iff_ker
+-/
 
+#print IsGroupHom.inv_iff_ker' /-
 @[to_additive]
 theorem inv_iff_ker' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a⁻¹ * b ∈ ker f := by
   rw [mem_ker] <;> exact one_iff_ker_inv' hf _ _
 #align is_group_hom.inv_iff_ker' IsGroupHom.inv_iff_ker'
 #align is_add_group_hom.neg_iff_ker' IsAddGroupHom.neg_iff_ker'
+-/
 
+#print IsGroupHom.image_subgroup /-
 @[to_additive]
 theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSubgroup s) :
     IsSubgroup (f '' s) :=
@@ -456,15 +497,19 @@ theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSub
     inv_mem := fun a ⟨b, hb, Eq⟩ => ⟨b⁻¹, hs.inv_mem hb, by rw [hf.map_inv]; simp [*]⟩ }
 #align is_group_hom.image_subgroup IsGroupHom.image_subgroup
 #align is_add_group_hom.image_add_subgroup IsAddGroupHom.image_addSubgroup
+-/
 
+#print IsGroupHom.range_subgroup /-
 @[to_additive]
 theorem range_subgroup {f : G → H} (hf : IsGroupHom f) : IsSubgroup (Set.range f) :=
   @Set.image_univ _ _ f ▸ hf.image_subgroup univ_subgroup.to_isSubgroup
 #align is_group_hom.range_subgroup IsGroupHom.range_subgroup
 #align is_add_group_hom.range_add_subgroup IsAddGroupHom.range_addSubgroup
+-/
 
 attribute [local simp] one_mem inv_mem mul_mem IsNormalSubgroup.normal
 
+#print IsGroupHom.preimage /-
 @[to_additive]
 theorem preimage {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsSubgroup s) :
     IsSubgroup (f ⁻¹' s) := by
@@ -473,7 +518,9 @@ theorem preimage {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsSubgroup
       hf.map_one, hf.map_inv, InvMemClass.inv_mem]
 #align is_group_hom.preimage IsGroupHom.preimage
 #align is_add_group_hom.preimage IsAddGroupHom.preimage
+-/
 
+#print IsGroupHom.preimage_normal /-
 @[to_additive]
 theorem preimage_normal {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsNormalSubgroup s) :
     IsNormalSubgroup (f ⁻¹' s) :=
@@ -483,13 +530,17 @@ theorem preimage_normal {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsNo
     Normal := by simp (config := { contextual := true }) [hs.normal, hf.map_mul, hf.map_inv] }
 #align is_group_hom.preimage_normal IsGroupHom.preimage_normal
 #align is_add_group_hom.preimage_normal IsAddGroupHom.preimage_normal
+-/
 
+#print IsGroupHom.isNormalSubgroup_ker /-
 @[to_additive]
 theorem isNormalSubgroup_ker {f : G → H} (hf : IsGroupHom f) : IsNormalSubgroup (ker f) :=
   hf.preimage_normal trivial_normal
 #align is_group_hom.is_normal_subgroup_ker IsGroupHom.isNormalSubgroup_ker
 #align is_add_group_hom.is_normal_add_subgroup_ker IsAddGroupHom.isNormalAddSubgroup_ker
+-/
 
+#print IsGroupHom.injective_of_trivial_ker /-
 @[to_additive]
 theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f = trivial G) :
     Function.Injective f := by
@@ -499,7 +550,9 @@ theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f =
   rw [eq_inv_of_mul_eq_one_left ha, inv_inv a₂]
 #align is_group_hom.injective_of_trivial_ker IsGroupHom.injective_of_trivial_ker
 #align is_add_group_hom.injective_of_trivial_ker IsAddGroupHom.injective_of_trivial_ker
+-/
 
+#print IsGroupHom.trivial_ker_of_injective /-
 @[to_additive]
 theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function.Injective f) :
     ker f = trivial G :=
@@ -511,14 +564,18 @@ theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function
       (by simp (config := { contextual := true }) [mem_ker, hf.map_one])
 #align is_group_hom.trivial_ker_of_injective IsGroupHom.trivial_ker_of_injective
 #align is_add_group_hom.trivial_ker_of_injective IsAddGroupHom.trivial_ker_of_injective
+-/
 
+#print IsGroupHom.injective_iff_trivial_ker /-
 @[to_additive]
 theorem injective_iff_trivial_ker {f : G → H} (hf : IsGroupHom f) :
     Function.Injective f ↔ ker f = trivial G :=
   ⟨hf.trivial_ker_of_injective, hf.injective_of_trivial_ker⟩
 #align is_group_hom.injective_iff_trivial_ker IsGroupHom.injective_iff_trivial_ker
 #align is_add_group_hom.injective_iff_trivial_ker IsAddGroupHom.injective_iff_trivial_ker
+-/
 
+#print IsGroupHom.trivial_ker_iff_eq_one /-
 @[to_additive]
 theorem trivial_ker_iff_eq_one {f : G → H} (hf : IsGroupHom f) :
     ker f = trivial G ↔ ∀ x, f x = 1 → x = 1 := by
@@ -526,6 +583,7 @@ theorem trivial_ker_iff_eq_one {f : G → H} (hf : IsGroupHom f) :
     exact ⟨fun h x hx => (h x).1 hx, fun h x => ⟨h x, fun hx => by rw [hx, hf.map_one]⟩⟩
 #align is_group_hom.trivial_ker_iff_eq_one IsGroupHom.trivial_ker_iff_eq_one
 #align is_add_group_hom.trivial_ker_iff_eq_zero IsAddGroupHom.trivial_ker_iff_eq_zero
+-/
 
 end IsGroupHom
 
@@ -632,6 +690,7 @@ theorem closure_subgroup {s : Set G} (hs : IsSubgroup s) : closure s = s :=
 #align add_group.closure_add_subgroup AddGroup.closure_addSubgroup
 -/
 
+#print Group.exists_list_of_mem_closure /-
 @[to_additive]
 theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
     ∃ l : List G, (∀ x ∈ l, x ∈ s ∨ x⁻¹ ∈ s) ∧ l.Prod = a :=
@@ -649,6 +708,7 @@ theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
     ⟨L1 ++ L2, List.forall_mem_append.2 ⟨HL1, HL3⟩, by rw [List.prod_append, HL2, HL4]⟩
 #align group.exists_list_of_mem_closure Group.exists_list_of_mem_closure
 #align add_group.exists_list_of_mem_closure AddGroup.exists_list_of_mem_closure
+-/
 
 #print Group.image_closure /-
 @[to_additive]
@@ -679,13 +739,16 @@ theorem mclosure_subset {s : Set G} : Monoid.Closure s ⊆ closure s :=
 #align add_group.mclosure_subset AddGroup.mclosure_subset
 -/
 
+#print Group.mclosure_inv_subset /-
 @[to_additive]
 theorem mclosure_inv_subset {s : Set G} : Monoid.Closure (Inv.inv ⁻¹' s) ⊆ closure s :=
   Monoid.closure_subset (closure.isSubgroup _).to_isSubmonoid fun x hx =>
     inv_inv x ▸ ((closure.isSubgroup _).inv_mem <| subset_closure hx)
 #align group.mclosure_inv_subset Group.mclosure_inv_subset
 #align add_group.mclosure_neg_subset AddGroup.mclosure_neg_subset
+-/
 
+#print Group.closure_eq_mclosure /-
 @[to_additive]
 theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.inv ⁻¹' s) :=
   Set.Subset.antisymm
@@ -708,7 +771,9 @@ theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.
         inv_inv x ▸ (IsSubgroup.inv_mem (closure.isSubgroup _) <| subset_closure hx))
 #align group.closure_eq_mclosure Group.closure_eq_mclosure
 #align add_group.closure_eq_mclosure AddGroup.closure_eq_mclosure
+-/
 
+#print Group.mem_closure_union_iff /-
 @[to_additive]
 theorem mem_closure_union_iff {G : Type _} [CommGroup G] {s t : Set G} {x : G} :
     x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x :=
@@ -723,6 +788,7 @@ theorem mem_closure_union_iff {G : Type _} [CommGroup G] {s t : Set G} {x : G} :
     rw [mul_assoc, mul_assoc, mul_left_comm yt]
 #align group.mem_closure_union_iff Group.mem_closure_union_iff
 #align add_group.mem_closure_union_iff AddGroup.mem_closure_union_iff
+-/
 
 end Group
 
@@ -847,6 +913,7 @@ def Subgroup.of [Group G] {s : Set G} (h : IsSubgroup s) : Subgroup G
 #align add_subgroup.of AddSubgroup.of
 -/
 
+#print Subgroup.isSubgroup /-
 @[to_additive]
 theorem Subgroup.isSubgroup [Group G] (K : Subgroup G) : IsSubgroup (K : Set G) :=
   { one_mem := K.one_mem'
@@ -854,6 +921,7 @@ theorem Subgroup.isSubgroup [Group G] (K : Subgroup G) : IsSubgroup (K : Set G)
     inv_mem := fun _ => K.inv_mem' }
 #align subgroup.is_subgroup Subgroup.isSubgroup
 #align add_subgroup.is_add_subgroup AddSubgroup.isAddSubgroup
+-/
 
 #print Subgroup.of_normal /-
 -- this will never fire if it's an instance

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

@@ -325,13 +325,11 @@ theorem center_normal : IsNormalSubgroup (center G) :=
       calc
         g * a⁻¹ = a⁻¹ * (g * a) * a⁻¹ := by simp [ha g]
         _ = a⁻¹ * g := by rw [← mul_assoc, mul_assoc] <;> simp
-        
     Normal := fun n ha g h =>
       calc
         h * (g * n * g⁻¹) = h * n := by simp [ha g, mul_assoc]
         _ = g * g⁻¹ * n * h := by rw [ha h] <;> simp
-        _ = g * n * g⁻¹ * h := by rw [mul_assoc g, ha g⁻¹, ← mul_assoc]
-         }
+        _ = g * n * g⁻¹ * h := by rw [mul_assoc g, ha g⁻¹, ← mul_assoc] }
 #align is_subgroup.center_normal IsSubgroup.center_normal
 #align is_add_subgroup.add_center_normal IsAddSubgroup.add_center_normal
 -/

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

@@ -304,7 +304,7 @@ theorem univ_subgroup : IsNormalSubgroup (@univ G) := by refine' { .. } <;> simp
 /-- The underlying set of the center of a group. -/
 @[to_additive add_center "The underlying set of the center of an additive group."]
 def center (G : Type _) [Group G] : Set G :=
-  { z | ∀ g, g * z = z * g }
+  {z | ∀ g, g * z = z * g}
 #align is_subgroup.center IsSubgroup.center
 #align is_add_subgroup.add_center IsAddSubgroup.addCenter
 -/
@@ -342,7 +342,7 @@ theorem center_normal : IsNormalSubgroup (center G) :=
 @[to_additive add_normalizer
       "The underlying set of the normalizer of a subset `S : set A` of an\n  additive group `A`. That is, the elements `a : A` such that `a + S - a = S`."]
 def normalizer (s : Set G) : Set G :=
-  { g : G | ∀ n, n ∈ s ↔ g * n * g⁻¹ ∈ s }
+  {g : G | ∀ n, n ∈ s ↔ g * n * g⁻¹ ∈ s}
 #align is_subgroup.normalizer IsSubgroup.normalizer
 #align is_add_subgroup.add_normalizer IsAddSubgroup.addNormalizer
 -/
@@ -572,7 +572,7 @@ inductive InClosure (s : Set G) : G → Prop
 @[to_additive
       "`add_group.closure s` is the additive subgroup generated by `s`, i.e., the\n  smallest additive subgroup containing `s`."]
 def closure (s : Set G) : Set G :=
-  { a | InClosure s a }
+  {a | InClosure s a}
 #align group.closure Group.closure
 #align add_group.closure AddGroup.closure
 -/
@@ -666,7 +666,7 @@ theorem image_closure [Group H] {f : G → H} (hf : IsGroupHom f) (s : Set G) :
       · rw [hf.map_inv]
         apply IsSubgroup.inv_mem (closure.is_subgroup _); assumption
       · rw [hf.to_is_monoid_hom.map_mul]
-        solve_by_elim [IsSubmonoid.mul_mem (closure.is_subgroup _).to_isSubmonoid] )
+        solve_by_elim [IsSubmonoid.mul_mem (closure.is_subgroup _).to_isSubmonoid])
     (closure_subset (hf.image_subgroup <| closure.isSubgroup _) <|
       Set.image_subset _ subset_closure)
 #align group.image_closure Group.image_closure

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

@@ -253,7 +253,7 @@ variable [Group G]
 theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a * b ∈ s) :
     b * a ∈ s := by
   have h : a⁻¹ * (a * b) * a⁻¹⁻¹ ∈ s := hs.Normal (a * b) hab a⁻¹
-  simp at h <;> exact h
+  simp at h  <;> exact h
 #align is_subgroup.mem_norm_comm IsSubgroup.mem_norm_comm
 #align is_add_subgroup.mem_norm_comm IsAddSubgroup.mem_norm_comm
 
@@ -395,7 +395,7 @@ variable [Group G] [Group H]
 @[to_additive]
 theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) : f a = f b :=
   by
-  rw [hf.map_mul, hf.map_inv] at h
+  rw [hf.map_mul, hf.map_inv] at h 
   rw [← inv_inv (f b), eq_inv_of_mul_eq_one_left h]
 #align is_group_hom.one_ker_inv IsGroupHom.one_ker_inv
 #align is_add_group_hom.zero_ker_neg IsAddGroupHom.zero_ker_neg
@@ -403,7 +403,7 @@ theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻
 @[to_additive]
 theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) : f a = f b :=
   by
-  rw [hf.map_mul, hf.map_inv] at h
+  rw [hf.map_mul, hf.map_inv] at h 
   apply inv_injective
   rw [eq_inv_of_mul_eq_one_left h]
 #align is_group_hom.one_ker_inv' IsGroupHom.one_ker_inv'
@@ -413,7 +413,7 @@ theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹
 theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a * b⁻¹) = 1 :=
   by
   have : f a * (f b)⁻¹ = 1 := by rw [h, mul_right_inv]
-  rwa [← hf.map_inv, ← hf.map_mul] at this
+  rwa [← hf.map_inv, ← hf.map_mul] at this 
 #align is_group_hom.inv_ker_one IsGroupHom.inv_ker_one
 #align is_add_group_hom.neg_ker_zero IsAddGroupHom.neg_ker_zero
 
@@ -421,7 +421,7 @@ theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b)
 theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a⁻¹ * b) = 1 :=
   by
   have : (f a)⁻¹ * f b = 1 := by rw [h, mul_left_inv]
-  rwa [← hf.map_inv, ← hf.map_mul] at this
+  rwa [← hf.map_inv, ← hf.map_mul] at this 
 #align is_group_hom.inv_ker_one' IsGroupHom.inv_ker_one'
 #align is_add_group_hom.neg_ker_zero' IsAddGroupHom.neg_ker_zero'
 
@@ -496,7 +496,7 @@ theorem isNormalSubgroup_ker {f : G → H} (hf : IsGroupHom f) : IsNormalSubgrou
 theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f = trivial G) :
     Function.Injective f := by
   intro a₁ a₂ hfa
-  simp [ext_iff, ker, IsSubgroup.trivial] at h
+  simp [ext_iff, ker, IsSubgroup.trivial] at h 
   have ha : a₁ * a₂⁻¹ = 1 := by rw [← h] <;> exact hf.inv_ker_one hfa
   rw [eq_inv_of_mul_eq_one_left ha, inv_inv a₂]
 #align is_group_hom.injective_of_trivial_ker IsGroupHom.injective_of_trivial_ker
@@ -509,7 +509,7 @@ theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function
     Iff.intro
       (fun hx => by
         suffices f x = f 1 by simpa using h this
-        simp [hf.map_one] <;> rwa [mem_ker] at hx)
+        simp [hf.map_one] <;> rwa [mem_ker] at hx )
       (by simp (config := { contextual := true }) [mem_ker, hf.map_one])
 #align is_group_hom.trivial_ker_of_injective IsGroupHom.trivial_ker_of_injective
 #align is_add_group_hom.trivial_ker_of_injective IsAddGroupHom.trivial_ker_of_injective

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

@@ -62,12 +62,6 @@ structure IsSubgroup (s : Set G) extends IsSubmonoid s : Prop where
 #align is_add_subgroup IsAddSubgroup
 -/
 
-/- warning: is_subgroup.div_mem -> IsSubgroup.div_mem is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (forall {x : G} {y : G}, (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x s) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) y s) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HDiv.hDiv.{u1, u1, u1} G G G (instHDiv.{u1} G (DivInvMonoid.toHasDiv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (forall {x : G} {y : G}, (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x s) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) y s) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HDiv.hDiv.{u1, u1, u1} G G G (instHDiv.{u1} G (DivInvMonoid.toDiv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) x y) s))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.div_mem IsSubgroup.div_memₓ'. -/
 @[to_additive]
 theorem IsSubgroup.div_mem {s : Set G} (hs : IsSubgroup s) {x y : G} (hx : x ∈ s) (hy : y ∈ s) :
     x / y ∈ s := by simpa only [div_eq_mul_inv] using hs.mul_mem hx (hs.inv_mem hy)
@@ -103,12 +97,6 @@ theorem Multiplicative.isSubgroup_iff {s : Set A} :
 #align multiplicative.is_subgroup_iff Multiplicative.isSubgroup_iff
 -/
 
-/- warning: is_subgroup.of_div -> IsSubgroup.of_div is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (s : Set.{u1} G), (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} 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))))))) s) -> (forall {a : G} {b : G}, (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) a s) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) b s) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) b)) s)) -> (IsSubgroup.{u1} G _inst_1 s)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (s : Set.{u1} G), (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} 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)))))) s) -> (forall {a : G} {b : G}, (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) a s) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) b s) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) b)) s)) -> (IsSubgroup.{u1} G _inst_1 s)
-Case conversion may be inaccurate. Consider using '#align is_subgroup.of_div IsSubgroup.of_divₓ'. -/
 @[to_additive ofAdd_neg]
 theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
     (div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s) : IsSubgroup s :=
@@ -125,24 +113,12 @@ theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
 #align is_subgroup.of_div IsSubgroup.of_div
 #align is_add_subgroup.of_add_neg IsAddSubgroup.of_add_neg
 
-/- warning: is_add_subgroup.of_sub -> IsAddSubgroup.of_sub is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] (s : Set.{u1} A), (Membership.Mem.{u1, u1} A (Set.{u1} A) (Set.hasMem.{u1} A) (OfNat.ofNat.{u1} A 0 (OfNat.mk.{u1} A 0 (Zero.zero.{u1} A (AddZeroClass.toHasZero.{u1} A (AddMonoid.toAddZeroClass.{u1} A (SubNegMonoid.toAddMonoid.{u1} A (AddGroup.toSubNegMonoid.{u1} A _inst_2))))))) s) -> (forall {a : A} {b : A}, (Membership.Mem.{u1, u1} A (Set.{u1} A) (Set.hasMem.{u1} A) a s) -> (Membership.Mem.{u1, u1} A (Set.{u1} A) (Set.hasMem.{u1} A) b s) -> (Membership.Mem.{u1, u1} A (Set.{u1} A) (Set.hasMem.{u1} A) (HSub.hSub.{u1, u1, u1} A A A (instHSub.{u1} A (SubNegMonoid.toHasSub.{u1} A (AddGroup.toSubNegMonoid.{u1} A _inst_2))) a b) s)) -> (IsAddSubgroup.{u1} A _inst_2 s)
-but is expected to have type
-  forall {A : Type.{u1}} [_inst_2 : AddGroup.{u1} A] (s : Set.{u1} A), (Membership.mem.{u1, u1} A (Set.{u1} A) (Set.instMembershipSet.{u1} A) (OfNat.ofNat.{u1} A 0 (Zero.toOfNat0.{u1} A (NegZeroClass.toZero.{u1} A (SubNegZeroMonoid.toNegZeroClass.{u1} A (SubtractionMonoid.toSubNegZeroMonoid.{u1} A (AddGroup.toSubtractionMonoid.{u1} A _inst_2)))))) s) -> (forall {a : A} {b : A}, (Membership.mem.{u1, u1} A (Set.{u1} A) (Set.instMembershipSet.{u1} A) a s) -> (Membership.mem.{u1, u1} A (Set.{u1} A) (Set.instMembershipSet.{u1} A) b s) -> (Membership.mem.{u1, u1} A (Set.{u1} A) (Set.instMembershipSet.{u1} A) (HSub.hSub.{u1, u1, u1} A A A (instHSub.{u1} A (SubNegMonoid.toSub.{u1} A (AddGroup.toSubNegMonoid.{u1} A _inst_2))) a b) s)) -> (IsAddSubgroup.{u1} A _inst_2 s)
-Case conversion may be inaccurate. Consider using '#align is_add_subgroup.of_sub IsAddSubgroup.of_subₓ'. -/
 theorem IsAddSubgroup.of_sub (s : Set A) (zero_mem : (0 : A) ∈ s)
     (sub_mem : ∀ {a b : A}, a ∈ s → b ∈ s → a - b ∈ s) : IsAddSubgroup s :=
   IsAddSubgroup.of_add_neg s zero_mem fun x y hx hy => by
     simpa only [sub_eq_add_neg] using sub_mem hx hy
 #align is_add_subgroup.of_sub IsAddSubgroup.of_sub
 
-/- warning: is_subgroup.inter -> IsSubgroup.inter is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s₁ : Set.{u1} G} {s₂ : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s₁) -> (IsSubgroup.{u1} G _inst_1 s₂) -> (IsSubgroup.{u1} G _inst_1 (Inter.inter.{u1} (Set.{u1} G) (Set.hasInter.{u1} G) s₁ s₂))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s₁ : Set.{u1} G} {s₂ : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s₁) -> (IsSubgroup.{u1} G _inst_1 s₂) -> (IsSubgroup.{u1} G _inst_1 (Inter.inter.{u1} (Set.{u1} G) (Set.instInterSet.{u1} G) s₁ s₂))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.inter IsSubgroup.interₓ'. -/
 @[to_additive]
 theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ : IsSubgroup s₂) :
     IsSubgroup (s₁ ∩ s₂) :=
@@ -185,36 +161,18 @@ variable [Group G] {s : Set G} (hs : IsSubgroup s)
 
 include hs
 
-/- warning: is_subgroup.inv_mem_iff -> IsSubgroup.inv_mem_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {a : G} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a) s) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) a s))
-but is expected to have type
-  forall {G : Type.{u1}} {a : G} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Iff (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a) s) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) a s))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.inv_mem_iff IsSubgroup.inv_mem_iffₓ'. -/
 @[to_additive]
 theorem inv_mem_iff : a⁻¹ ∈ s ↔ a ∈ s :=
   ⟨fun h => by simpa using hs.inv_mem h, inv_mem hs⟩
 #align is_subgroup.inv_mem_iff IsSubgroup.inv_mem_iff
 #align is_add_subgroup.neg_mem_iff IsAddSubgroup.neg_mem_iff
 
-/- warning: is_subgroup.mul_mem_cancel_right -> IsSubgroup.mul_mem_cancel_right is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {a : G} {b : G} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) a s) -> (Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) b a) s) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) b s))
-but is expected to have type
-  forall {G : Type.{u1}} {a : G} {b : G} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) a s) -> (Iff (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) b a) s) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) b s))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.mul_mem_cancel_right IsSubgroup.mul_mem_cancel_rightₓ'. -/
 @[to_additive]
 theorem mul_mem_cancel_right (h : a ∈ s) : b * a ∈ s ↔ b ∈ s :=
   ⟨fun hba => by simpa using hs.mul_mem hba (hs.inv_mem h), fun hb => hs.mul_mem hb h⟩
 #align is_subgroup.mul_mem_cancel_right IsSubgroup.mul_mem_cancel_right
 #align is_add_subgroup.add_mem_cancel_right IsAddSubgroup.add_mem_cancel_right
 
-/- warning: is_subgroup.mul_mem_cancel_left -> IsSubgroup.mul_mem_cancel_left is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {a : G} {b : G} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) a s) -> (Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a b) s) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) b s))
-but is expected to have type
-  forall {G : Type.{u1}} {a : G} {b : G} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) a s) -> (Iff (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a b) s) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) b s))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.mul_mem_cancel_left IsSubgroup.mul_mem_cancel_leftₓ'. -/
 @[to_additive]
 theorem mul_mem_cancel_left (h : a ∈ s) : a * b ∈ s ↔ b ∈ s :=
   ⟨fun hab => by simpa using hs.mul_mem (hs.inv_mem h) hab, hs.mul_mem h⟩
@@ -290,12 +248,6 @@ namespace IsSubgroup
 
 variable [Group G]
 
-/- warning: is_subgroup.mem_norm_comm -> IsSubgroup.mem_norm_comm is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsNormalSubgroup.{u1} G _inst_1 s) -> (forall {a : G} {b : G}, (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a b) s) -> (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) b a) s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsNormalSubgroup.{u1} G _inst_1 s) -> (forall {a : G} {b : G}, (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a b) s) -> (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) b a) s))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.mem_norm_comm IsSubgroup.mem_norm_commₓ'. -/
 -- Normal subgroup properties
 @[to_additive]
 theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a * b ∈ s) :
@@ -305,12 +257,6 @@ theorem mem_norm_comm {s : Set G} (hs : IsNormalSubgroup s) {a b : G} (hab : a *
 #align is_subgroup.mem_norm_comm IsSubgroup.mem_norm_comm
 #align is_add_subgroup.mem_norm_comm IsAddSubgroup.mem_norm_comm
 
-/- warning: is_subgroup.mem_norm_comm_iff -> IsSubgroup.mem_norm_comm_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsNormalSubgroup.{u1} G _inst_1 s) -> (forall {a : G} {b : G}, Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a b) s) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) b a) s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsNormalSubgroup.{u1} G _inst_1 s) -> (forall {a : G} {b : G}, Iff (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a b) s) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) b a) s))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.mem_norm_comm_iff IsSubgroup.mem_norm_comm_iffₓ'. -/
 @[to_additive]
 theorem mem_norm_comm_iff {s : Set G} (hs : IsNormalSubgroup s) {a b : G} : a * b ∈ s ↔ b * a ∈ s :=
   ⟨mem_norm_comm hs, mem_norm_comm hs⟩
@@ -326,12 +272,6 @@ def trivial (G : Type _) [Group G] : Set G :=
 #align is_add_subgroup.trivial IsAddSubgroup.trivial
 -/
 
-/- warning: is_subgroup.mem_trivial -> IsSubgroup.mem_trivial is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {g : G}, Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) g (IsSubgroup.trivial.{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 (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) g (IsSubgroup.trivial.{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 is_subgroup.mem_trivial IsSubgroup.mem_trivialₓ'. -/
 @[simp, to_additive]
 theorem mem_trivial {g : G} : g ∈ trivial G ↔ g = 1 :=
   mem_singleton_iff
@@ -346,12 +286,6 @@ theorem trivial_normal : IsNormalSubgroup (trivial G) := by
 #align is_add_subgroup.trivial_normal IsAddSubgroup.trivial_normal
 -/
 
-/- warning: is_subgroup.eq_trivial_iff -> IsSubgroup.eq_trivial_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Iff (Eq.{succ u1} (Set.{u1} G) s (IsSubgroup.trivial.{u1} G _inst_1)) (forall (x : G), (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x s) -> (Eq.{succ u1} G x (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] {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (Iff (Eq.{succ u1} (Set.{u1} G) s (IsSubgroup.trivial.{u1} G _inst_1)) (forall (x : G), (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x s) -> (Eq.{succ u1} G x (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 is_subgroup.eq_trivial_iff IsSubgroup.eq_trivial_iffₓ'. -/
 @[to_additive]
 theorem eq_trivial_iff {s : Set G} (hs : IsSubgroup s) : s = trivial G ↔ ∀ x ∈ s, x = (1 : G) := by
   simp only [Set.ext_iff, IsSubgroup.mem_trivial] <;>
@@ -375,12 +309,6 @@ def center (G : Type _) [Group G] : Set G :=
 #align is_add_subgroup.add_center IsAddSubgroup.addCenter
 -/
 
-/- warning: is_subgroup.mem_center -> IsSubgroup.mem_center is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {a : G}, Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) a (IsSubgroup.center.{u1} G _inst_1)) (forall (g : G), Eq.{succ u1} G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) g a) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a g))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {a : G}, Iff (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) a (IsSubgroup.center.{u1} G _inst_1)) (forall (g : G), Eq.{succ u1} G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) g a) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a g))
-Case conversion may be inaccurate. Consider using '#align is_subgroup.mem_center IsSubgroup.mem_centerₓ'. -/
 @[to_additive mem_add_center]
 theorem mem_center {a : G} : a ∈ center G ↔ ∀ g, g * a = a * g :=
   Iff.rfl
@@ -456,12 +384,6 @@ def ker [Group H] (f : G → H) : Set G :=
 #align is_add_group_hom.ker IsAddGroupHom.ker
 -/
 
-/- warning: is_group_hom.mem_ker -> IsGroupHom.mem_ker is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u2} H] (f : G -> H) {x : G}, Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x (IsGroupHom.ker.{u1, u2} G H _inst_1 f)) (Eq.{succ u2} H (f x) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_1))))))))
-but is expected to have type
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u2} H] (f : G -> H) {x : G}, Iff (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (IsGroupHom.ker.{u1, u2} G H _inst_1 f)) (Eq.{succ u2} H (f x) (OfNat.ofNat.{u2} H 1 (One.toOfNat1.{u2} H (InvOneClass.toOne.{u2} H (DivInvOneMonoid.toInvOneClass.{u2} H (DivisionMonoid.toDivInvOneMonoid.{u2} H (Group.toDivisionMonoid.{u2} H _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.mem_ker IsGroupHom.mem_kerₓ'. -/
 @[to_additive]
 theorem mem_ker [Group H] (f : G → H) {x : G} : x ∈ ker f ↔ f x = 1 :=
   mem_trivial
@@ -470,12 +392,6 @@ theorem mem_ker [Group H] (f : G → H) {x : G} : x ∈ ker f ↔ f x = 1 :=
 
 variable [Group G] [Group H]
 
-/- warning: is_group_hom.one_ker_inv -> IsGroupHom.one_ker_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u2} H (f (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) b))) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_2)))))))) -> (Eq.{succ u2} H (f a) (f b)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u1} H (f (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) b))) (OfNat.ofNat.{u1} H 1 (One.toOfNat1.{u1} H (InvOneClass.toOne.{u1} H (DivInvOneMonoid.toInvOneClass.{u1} H (DivisionMonoid.toDivInvOneMonoid.{u1} H (Group.toDivisionMonoid.{u1} H _inst_2))))))) -> (Eq.{succ u1} H (f a) (f b)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.one_ker_inv IsGroupHom.one_ker_invₓ'. -/
 @[to_additive]
 theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) : f a = f b :=
   by
@@ -484,12 +400,6 @@ theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻
 #align is_group_hom.one_ker_inv IsGroupHom.one_ker_inv
 #align is_add_group_hom.zero_ker_neg IsAddGroupHom.zero_ker_neg
 
-/- warning: is_group_hom.one_ker_inv' -> IsGroupHom.one_ker_inv' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u2} H (f (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a) b)) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_2)))))))) -> (Eq.{succ u2} H (f a) (f b)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u1} H (f (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) a) b)) (OfNat.ofNat.{u1} H 1 (One.toOfNat1.{u1} H (InvOneClass.toOne.{u1} H (DivInvOneMonoid.toInvOneClass.{u1} H (DivisionMonoid.toDivInvOneMonoid.{u1} H (Group.toDivisionMonoid.{u1} H _inst_2))))))) -> (Eq.{succ u1} H (f a) (f b)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.one_ker_inv' IsGroupHom.one_ker_inv'ₓ'. -/
 @[to_additive]
 theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) : f a = f b :=
   by
@@ -499,12 +409,6 @@ theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹
 #align is_group_hom.one_ker_inv' IsGroupHom.one_ker_inv'
 #align is_add_group_hom.zero_ker_neg' IsAddGroupHom.zero_ker_neg'
 
-/- warning: is_group_hom.inv_ker_one -> IsGroupHom.inv_ker_one is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u2} H (f a) (f b)) -> (Eq.{succ u2} H (f (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) b))) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_2)))))))))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u1} H (f a) (f b)) -> (Eq.{succ u1} H (f (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) b))) (OfNat.ofNat.{u1} H 1 (One.toOfNat1.{u1} H (InvOneClass.toOne.{u1} H (DivInvOneMonoid.toInvOneClass.{u1} H (DivisionMonoid.toDivInvOneMonoid.{u1} H (Group.toDivisionMonoid.{u1} H _inst_2))))))))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.inv_ker_one IsGroupHom.inv_ker_oneₓ'. -/
 @[to_additive]
 theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a * b⁻¹) = 1 :=
   by
@@ -513,12 +417,6 @@ theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b)
 #align is_group_hom.inv_ker_one IsGroupHom.inv_ker_one
 #align is_add_group_hom.neg_ker_zero IsAddGroupHom.neg_ker_zero
 
-/- warning: is_group_hom.inv_ker_one' -> IsGroupHom.inv_ker_one' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u2} H (f a) (f b)) -> (Eq.{succ u2} H (f (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a) b)) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_2)))))))))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall {a : G} {b : G}, (Eq.{succ u1} H (f a) (f b)) -> (Eq.{succ u1} H (f (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) a) b)) (OfNat.ofNat.{u1} H 1 (One.toOfNat1.{u1} H (InvOneClass.toOne.{u1} H (DivInvOneMonoid.toInvOneClass.{u1} H (DivisionMonoid.toDivInvOneMonoid.{u1} H (Group.toDivisionMonoid.{u1} H _inst_2))))))))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.inv_ker_one' IsGroupHom.inv_ker_one'ₓ'. -/
 @[to_additive]
 theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a⁻¹ * b) = 1 :=
   by
@@ -527,60 +425,30 @@ theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b)
 #align is_group_hom.inv_ker_one' IsGroupHom.inv_ker_one'
 #align is_add_group_hom.neg_ker_zero' IsAddGroupHom.neg_ker_zero'
 
-/- warning: is_group_hom.one_iff_ker_inv -> IsGroupHom.one_iff_ker_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u2} H (f a) (f b)) (Eq.{succ u2} H (f (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) b))) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_2)))))))))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u1} H (f a) (f b)) (Eq.{succ u1} H (f (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) b))) (OfNat.ofNat.{u1} H 1 (One.toOfNat1.{u1} H (InvOneClass.toOne.{u1} H (DivInvOneMonoid.toInvOneClass.{u1} H (DivisionMonoid.toDivInvOneMonoid.{u1} H (Group.toDivisionMonoid.{u1} H _inst_2))))))))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.one_iff_ker_inv IsGroupHom.one_iff_ker_invₓ'. -/
 @[to_additive]
 theorem one_iff_ker_inv {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a * b⁻¹) = 1 :=
   ⟨hf.inv_ker_one, hf.one_ker_inv⟩
 #align is_group_hom.one_iff_ker_inv IsGroupHom.one_iff_ker_inv
 #align is_add_group_hom.zero_iff_ker_neg IsAddGroupHom.zero_iff_ker_neg
 
-/- warning: is_group_hom.one_iff_ker_inv' -> IsGroupHom.one_iff_ker_inv' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u2} H (f a) (f b)) (Eq.{succ u2} H (f (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a) b)) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_2)))))))))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u1} H (f a) (f b)) (Eq.{succ u1} H (f (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) a) b)) (OfNat.ofNat.{u1} H 1 (One.toOfNat1.{u1} H (InvOneClass.toOne.{u1} H (DivInvOneMonoid.toInvOneClass.{u1} H (DivisionMonoid.toDivInvOneMonoid.{u1} H (Group.toDivisionMonoid.{u1} H _inst_2))))))))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.one_iff_ker_inv' IsGroupHom.one_iff_ker_inv'ₓ'. -/
 @[to_additive]
 theorem one_iff_ker_inv' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ f (a⁻¹ * b) = 1 :=
   ⟨hf.inv_ker_one', hf.one_ker_inv'⟩
 #align is_group_hom.one_iff_ker_inv' IsGroupHom.one_iff_ker_inv'
 #align is_add_group_hom.zero_iff_ker_neg' IsAddGroupHom.zero_iff_ker_neg'
 
-/- warning: is_group_hom.inv_iff_ker -> IsGroupHom.inv_iff_ker is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u2} H (f a) (f b)) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) a (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) b)) (IsGroupHom.ker.{u1, u2} G H _inst_2 f)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u1} H (f a) (f b)) (Membership.mem.{u2, u2} G (Set.{u2} G) (Set.instMembershipSet.{u2} G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) b)) (IsGroupHom.ker.{u2, u1} G H _inst_2 f)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.inv_iff_ker IsGroupHom.inv_iff_kerₓ'. -/
 @[to_additive]
 theorem inv_iff_ker {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a * b⁻¹ ∈ ker f := by
   rw [mem_ker] <;> exact one_iff_ker_inv hf _ _
 #align is_group_hom.inv_iff_ker IsGroupHom.inv_iff_ker
 #align is_add_group_hom.neg_iff_ker IsAddGroupHom.neg_iff_ker
 
-/- warning: is_group_hom.inv_iff_ker' -> IsGroupHom.inv_iff_ker' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u2} H (f a) (f b)) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a) b) (IsGroupHom.ker.{u1, u2} G H _inst_2 f)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall (a : G) (b : G), Iff (Eq.{succ u1} H (f a) (f b)) (Membership.mem.{u2, u2} G (Set.{u2} G) (Set.instMembershipSet.{u2} G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (Inv.inv.{u2} G (InvOneClass.toInv.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))) a) b) (IsGroupHom.ker.{u2, u1} G H _inst_2 f)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.inv_iff_ker' IsGroupHom.inv_iff_ker'ₓ'. -/
 @[to_additive]
 theorem inv_iff_ker' {f : G → H} (hf : IsGroupHom f) (a b : G) : f a = f b ↔ a⁻¹ * b ∈ ker f := by
   rw [mem_ker] <;> exact one_iff_ker_inv' hf _ _
 #align is_group_hom.inv_iff_ker' IsGroupHom.inv_iff_ker'
 #align is_add_group_hom.neg_iff_ker' IsAddGroupHom.neg_iff_ker'
 
-/- warning: is_group_hom.image_subgroup -> IsGroupHom.image_subgroup is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall {s : Set.{u1} G}, (IsSubgroup.{u1} G _inst_1 s) -> (IsSubgroup.{u2} H _inst_2 (Set.image.{u1, u2} G H f s)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall {s : Set.{u2} G}, (IsSubgroup.{u2} G _inst_1 s) -> (IsSubgroup.{u1} H _inst_2 (Set.image.{u2, u1} G H f s)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.image_subgroup IsGroupHom.image_subgroupₓ'. -/
 @[to_additive]
 theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSubgroup s) :
     IsSubgroup (f '' s) :=
@@ -591,12 +459,6 @@ theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSub
 #align is_group_hom.image_subgroup IsGroupHom.image_subgroup
 #align is_add_group_hom.image_add_subgroup IsAddGroupHom.image_addSubgroup
 
-/- warning: is_group_hom.range_subgroup -> IsGroupHom.range_subgroup is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (IsSubgroup.{u2} H _inst_2 (Set.range.{u2, succ u1} H G f))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (IsSubgroup.{u1} H _inst_2 (Set.range.{u1, succ u2} H G f))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.range_subgroup IsGroupHom.range_subgroupₓ'. -/
 @[to_additive]
 theorem range_subgroup {f : G → H} (hf : IsGroupHom f) : IsSubgroup (Set.range f) :=
   @Set.image_univ _ _ f ▸ hf.image_subgroup univ_subgroup.to_isSubgroup
@@ -605,12 +467,6 @@ theorem range_subgroup {f : G → H} (hf : IsGroupHom f) : IsSubgroup (Set.range
 
 attribute [local simp] one_mem inv_mem mul_mem IsNormalSubgroup.normal
 
-/- warning: is_group_hom.preimage -> IsGroupHom.preimage is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall {s : Set.{u2} H}, (IsSubgroup.{u2} H _inst_2 s) -> (IsSubgroup.{u1} G _inst_1 (Set.preimage.{u1, u2} G H f s)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall {s : Set.{u1} H}, (IsSubgroup.{u1} H _inst_2 s) -> (IsSubgroup.{u2} G _inst_1 (Set.preimage.{u2, u1} G H f s)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.preimage IsGroupHom.preimageₓ'. -/
 @[to_additive]
 theorem preimage {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsSubgroup s) :
     IsSubgroup (f ⁻¹' s) := by
@@ -620,12 +476,6 @@ theorem preimage {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsSubgroup
 #align is_group_hom.preimage IsGroupHom.preimage
 #align is_add_group_hom.preimage IsAddGroupHom.preimage
 
-/- warning: is_group_hom.preimage_normal -> IsGroupHom.preimage_normal is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (forall {s : Set.{u2} H}, (IsNormalSubgroup.{u2} H _inst_2 s) -> (IsNormalSubgroup.{u1} G _inst_1 (Set.preimage.{u1, u2} G H f s)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (forall {s : Set.{u1} H}, (IsNormalSubgroup.{u1} H _inst_2 s) -> (IsNormalSubgroup.{u2} G _inst_1 (Set.preimage.{u2, u1} G H f s)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.preimage_normal IsGroupHom.preimage_normalₓ'. -/
 @[to_additive]
 theorem preimage_normal {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsNormalSubgroup s) :
     IsNormalSubgroup (f ⁻¹' s) :=
@@ -636,24 +486,12 @@ theorem preimage_normal {f : G → H} (hf : IsGroupHom f) {s : Set H} (hs : IsNo
 #align is_group_hom.preimage_normal IsGroupHom.preimage_normal
 #align is_add_group_hom.preimage_normal IsAddGroupHom.preimage_normal
 
-/- warning: is_group_hom.is_normal_subgroup_ker -> IsGroupHom.isNormalSubgroup_ker is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (IsNormalSubgroup.{u1} G _inst_1 (IsGroupHom.ker.{u1, u2} G H _inst_2 f))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (IsNormalSubgroup.{u2} G _inst_1 (IsGroupHom.ker.{u2, u1} G H _inst_2 f))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.is_normal_subgroup_ker IsGroupHom.isNormalSubgroup_kerₓ'. -/
 @[to_additive]
 theorem isNormalSubgroup_ker {f : G → H} (hf : IsGroupHom f) : IsNormalSubgroup (ker f) :=
   hf.preimage_normal trivial_normal
 #align is_group_hom.is_normal_subgroup_ker IsGroupHom.isNormalSubgroup_ker
 #align is_add_group_hom.is_normal_add_subgroup_ker IsAddGroupHom.isNormalAddSubgroup_ker
 
-/- warning: is_group_hom.injective_of_trivial_ker -> IsGroupHom.injective_of_trivial_ker is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (Eq.{succ u1} (Set.{u1} G) (IsGroupHom.ker.{u1, u2} G H _inst_2 f) (IsSubgroup.trivial.{u1} G _inst_1)) -> (Function.Injective.{succ u1, succ u2} G H f)
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (Eq.{succ u2} (Set.{u2} G) (IsGroupHom.ker.{u2, u1} G H _inst_2 f) (IsSubgroup.trivial.{u2} G _inst_1)) -> (Function.Injective.{succ u2, succ u1} G H f)
-Case conversion may be inaccurate. Consider using '#align is_group_hom.injective_of_trivial_ker IsGroupHom.injective_of_trivial_kerₓ'. -/
 @[to_additive]
 theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f = trivial G) :
     Function.Injective f := by
@@ -664,12 +502,6 @@ theorem injective_of_trivial_ker {f : G → H} (hf : IsGroupHom f) (h : ker f =
 #align is_group_hom.injective_of_trivial_ker IsGroupHom.injective_of_trivial_ker
 #align is_add_group_hom.injective_of_trivial_ker IsAddGroupHom.injective_of_trivial_ker
 
-/- warning: is_group_hom.trivial_ker_of_injective -> IsGroupHom.trivial_ker_of_injective is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (Function.Injective.{succ u1, succ u2} G H f) -> (Eq.{succ u1} (Set.{u1} G) (IsGroupHom.ker.{u1, u2} G H _inst_2 f) (IsSubgroup.trivial.{u1} G _inst_1))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (Function.Injective.{succ u2, succ u1} G H f) -> (Eq.{succ u2} (Set.{u2} G) (IsGroupHom.ker.{u2, u1} G H _inst_2 f) (IsSubgroup.trivial.{u2} G _inst_1))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.trivial_ker_of_injective IsGroupHom.trivial_ker_of_injectiveₓ'. -/
 @[to_additive]
 theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function.Injective f) :
     ker f = trivial G :=
@@ -682,12 +514,6 @@ theorem trivial_ker_of_injective {f : G → H} (hf : IsGroupHom f) (h : Function
 #align is_group_hom.trivial_ker_of_injective IsGroupHom.trivial_ker_of_injective
 #align is_add_group_hom.trivial_ker_of_injective IsAddGroupHom.trivial_ker_of_injective
 
-/- warning: is_group_hom.injective_iff_trivial_ker -> IsGroupHom.injective_iff_trivial_ker is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (Iff (Function.Injective.{succ u1, succ u2} G H f) (Eq.{succ u1} (Set.{u1} G) (IsGroupHom.ker.{u1, u2} G H _inst_2 f) (IsSubgroup.trivial.{u1} G _inst_1)))
-but is expected to have type
-  forall {G : Type.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (Iff (Function.Injective.{succ u2, succ u1} G H f) (Eq.{succ u2} (Set.{u2} G) (IsGroupHom.ker.{u2, u1} G H _inst_2 f) (IsSubgroup.trivial.{u2} G _inst_1)))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.injective_iff_trivial_ker IsGroupHom.injective_iff_trivial_kerₓ'. -/
 @[to_additive]
 theorem injective_iff_trivial_ker {f : G → H} (hf : IsGroupHom f) :
     Function.Injective f ↔ ker f = trivial G :=
@@ -695,12 +521,6 @@ theorem injective_iff_trivial_ker {f : G → H} (hf : IsGroupHom f) :
 #align is_group_hom.injective_iff_trivial_ker IsGroupHom.injective_iff_trivial_ker
 #align is_add_group_hom.injective_iff_trivial_ker IsAddGroupHom.injective_iff_trivial_ker
 
-/- warning: is_group_hom.trivial_ker_iff_eq_one -> IsGroupHom.trivial_ker_iff_eq_one is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} {H : Type.{u2}} [_inst_1 : Group.{u1} G] [_inst_2 : Group.{u2} H] {f : G -> H}, (IsGroupHom.{u1, u2} G H _inst_1 _inst_2 f) -> (Iff (Eq.{succ u1} (Set.{u1} G) (IsGroupHom.ker.{u1, u2} G H _inst_2 f) (IsSubgroup.trivial.{u1} G _inst_1)) (forall (x : G), (Eq.{succ u2} H (f x) (OfNat.ofNat.{u2} H 1 (OfNat.mk.{u2} H 1 (One.one.{u2} H (MulOneClass.toHasOne.{u2} H (Monoid.toMulOneClass.{u2} H (DivInvMonoid.toMonoid.{u2} H (Group.toDivInvMonoid.{u2} H _inst_2)))))))) -> (Eq.{succ u1} G x (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.{u2}} {H : Type.{u1}} [_inst_1 : Group.{u2} G] [_inst_2 : Group.{u1} H] {f : G -> H}, (IsGroupHom.{u2, u1} G H _inst_1 _inst_2 f) -> (Iff (Eq.{succ u2} (Set.{u2} G) (IsGroupHom.ker.{u2, u1} G H _inst_2 f) (IsSubgroup.trivial.{u2} G _inst_1)) (forall (x : G), (Eq.{succ u1} H (f x) (OfNat.ofNat.{u1} H 1 (One.toOfNat1.{u1} H (InvOneClass.toOne.{u1} H (DivInvOneMonoid.toInvOneClass.{u1} H (DivisionMonoid.toDivInvOneMonoid.{u1} H (Group.toDivisionMonoid.{u1} H _inst_2))))))) -> (Eq.{succ u2} G x (OfNat.ofNat.{u2} G 1 (One.toOfNat1.{u2} G (InvOneClass.toOne.{u2} G (DivInvOneMonoid.toInvOneClass.{u2} G (DivisionMonoid.toDivInvOneMonoid.{u2} G (Group.toDivisionMonoid.{u2} G _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align is_group_hom.trivial_ker_iff_eq_one IsGroupHom.trivial_ker_iff_eq_oneₓ'. -/
 @[to_additive]
 theorem trivial_ker_iff_eq_one {f : G → H} (hf : IsGroupHom f) :
     ker f = trivial G ↔ ∀ x, f x = 1 → x = 1 := by
@@ -814,12 +634,6 @@ theorem closure_subgroup {s : Set G} (hs : IsSubgroup s) : closure s = s :=
 #align add_group.closure_add_subgroup AddGroup.closure_addSubgroup
 -/
 
-/- warning: group.exists_list_of_mem_closure -> Group.exists_list_of_mem_closure is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G} {a : G}, (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) a (Group.closure.{u1} G _inst_1 s)) -> (Exists.{succ u1} (List.{u1} G) (fun (l : List.{u1} G) => And (forall (x : G), (Membership.Mem.{u1, u1} G (List.{u1} G) (List.hasMem.{u1} G) x l) -> (Or (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x s) (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) x) s))) (Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (MulOneClass.toHasOne.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) l) a)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G} {a : G}, (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) a (Group.closure.{u1} G _inst_1 s)) -> (Exists.{succ u1} (List.{u1} G) (fun (l : List.{u1} G) => And (forall (x : G), (Membership.mem.{u1, u1} G (List.{u1} G) (List.instMembershipList.{u1} G) x l) -> (Or (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x s) (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) x) s))) (Eq.{succ u1} G (List.prod.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))) (InvOneClass.toOne.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) l) a)))
-Case conversion may be inaccurate. Consider using '#align group.exists_list_of_mem_closure Group.exists_list_of_mem_closureₓ'. -/
 @[to_additive]
 theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
     ∃ l : List G, (∀ x ∈ l, x ∈ s ∨ x⁻¹ ∈ s) ∧ l.Prod = a :=
@@ -867,12 +681,6 @@ theorem mclosure_subset {s : Set G} : Monoid.Closure s ⊆ closure s :=
 #align add_group.mclosure_subset AddGroup.mclosure_subset
 -/
 
-/- warning: group.mclosure_inv_subset -> Group.mclosure_inv_subset is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, HasSubset.Subset.{u1} (Set.{u1} G) (Set.hasSubset.{u1} G) (Monoid.Closure.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (Set.preimage.{u1, u1} G G (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)) (Group.closure.{u1} G _inst_1 s)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, HasSubset.Subset.{u1} (Set.{u1} G) (Set.instHasSubsetSet.{u1} G) (Monoid.Closure.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (Set.preimage.{u1, u1} G G (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))) s)) (Group.closure.{u1} G _inst_1 s)
-Case conversion may be inaccurate. Consider using '#align group.mclosure_inv_subset Group.mclosure_inv_subsetₓ'. -/
 @[to_additive]
 theorem mclosure_inv_subset {s : Set G} : Monoid.Closure (Inv.inv ⁻¹' s) ⊆ closure s :=
   Monoid.closure_subset (closure.isSubgroup _).to_isSubmonoid fun x hx =>
@@ -880,12 +688,6 @@ theorem mclosure_inv_subset {s : Set G} : Monoid.Closure (Inv.inv ⁻¹' s) ⊆
 #align group.mclosure_inv_subset Group.mclosure_inv_subset
 #align add_group.mclosure_neg_subset AddGroup.mclosure_neg_subset
 
-/- warning: group.closure_eq_mclosure -> Group.closure_eq_mclosure is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, Eq.{succ u1} (Set.{u1} G) (Group.closure.{u1} G _inst_1 s) (Monoid.Closure.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (Union.union.{u1} (Set.{u1} G) (Set.hasUnion.{u1} G) s (Set.preimage.{u1, u1} G G (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] {s : Set.{u1} G}, Eq.{succ u1} (Set.{u1} G) (Group.closure.{u1} G _inst_1 s) (Monoid.Closure.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) (Union.union.{u1} (Set.{u1} G) (Set.instUnionSet.{u1} G) s (Set.preimage.{u1, u1} G G (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1))))) s)))
-Case conversion may be inaccurate. Consider using '#align group.closure_eq_mclosure Group.closure_eq_mclosureₓ'. -/
 @[to_additive]
 theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.inv ⁻¹' s) :=
   Set.Subset.antisymm
@@ -909,12 +711,6 @@ theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.
 #align group.closure_eq_mclosure Group.closure_eq_mclosure
 #align add_group.closure_eq_mclosure AddGroup.closure_eq_mclosure
 
-/- warning: group.mem_closure_union_iff -> Group.mem_closure_union_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_2 : CommGroup.{u1} G] {s : Set.{u1} G} {t : Set.{u1} G} {x : G}, Iff (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) x (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) (Union.union.{u1} (Set.{u1} G) (Set.hasUnion.{u1} G) s t))) (Exists.{succ u1} G (fun (y : G) => Exists.{0} (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) y (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) s)) (fun (H : Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) y (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) s)) => Exists.{succ u1} G (fun (z : G) => Exists.{0} (Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) z (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) t)) (fun (H : Membership.Mem.{u1, u1} G (Set.{u1} G) (Set.hasMem.{u1} G) z (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) t)) => Eq.{succ u1} G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_2)))))) y z) x)))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_2 : CommGroup.{u1} G] {s : Set.{u1} G} {t : Set.{u1} G} {x : G}, Iff (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) x (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) (Union.union.{u1} (Set.{u1} G) (Set.instUnionSet.{u1} G) s t))) (Exists.{succ u1} G (fun (y : G) => And (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) y (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) s)) (Exists.{succ u1} G (fun (z : G) => And (Membership.mem.{u1, u1} G (Set.{u1} G) (Set.instMembershipSet.{u1} G) z (Group.closure.{u1} G (CommGroup.toGroup.{u1} G _inst_2) t)) (Eq.{succ u1} G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G (CommGroup.toGroup.{u1} G _inst_2)))))) y z) x)))))
-Case conversion may be inaccurate. Consider using '#align group.mem_closure_union_iff Group.mem_closure_union_iffₓ'. -/
 @[to_additive]
 theorem mem_closure_union_iff {G : Type _} [CommGroup G] {s t : Set G} {x : G} :
     x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x :=
@@ -1053,12 +849,6 @@ def Subgroup.of [Group G] {s : Set G} (h : IsSubgroup s) : Subgroup G
 #align add_subgroup.of AddSubgroup.of
 -/
 
-/- warning: subgroup.is_subgroup -> Subgroup.isSubgroup is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (K : Subgroup.{u1} G _inst_1), IsSubgroup.{u1} G _inst_1 ((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)))) K)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] (K : Subgroup.{u1} G _inst_1), IsSubgroup.{u1} G _inst_1 (SetLike.coe.{u1, u1} (Subgroup.{u1} G _inst_1) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_1) K)
-Case conversion may be inaccurate. Consider using '#align subgroup.is_subgroup Subgroup.isSubgroupₓ'. -/
 @[to_additive]
 theorem Subgroup.isSubgroup [Group G] (K : Subgroup G) : IsSubgroup (K : Set G) :=
   { one_mem := K.one_mem'

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

@@ -587,10 +587,7 @@ theorem image_subgroup {f : G → H} (hf : IsGroupHom f) {s : Set G} (hs : IsSub
   { mul_mem := fun a₁ a₂ ⟨b₁, hb₁, eq₁⟩ ⟨b₂, hb₂, eq₂⟩ =>
       ⟨b₁ * b₂, hs.mul_mem hb₁ hb₂, by simp [eq₁, eq₂, hf.map_mul]⟩
     one_mem := ⟨1, hs.to_isSubmonoid.one_mem, hf.map_one⟩
-    inv_mem := fun a ⟨b, hb, Eq⟩ =>
-      ⟨b⁻¹, hs.inv_mem hb, by
-        rw [hf.map_inv]
-        simp [*]⟩ }
+    inv_mem := fun a ⟨b, hb, Eq⟩ => ⟨b⁻¹, hs.inv_mem hb, by rw [hf.map_inv]; simp [*]⟩ }
 #align is_group_hom.image_subgroup IsGroupHom.image_subgroup
 #align is_add_group_hom.image_add_subgroup IsAddGroupHom.image_addSubgroup
 
@@ -853,8 +850,7 @@ theorem image_closure [Group H] {f : G → H} (hf : IsGroupHom f) (s : Set G) :
       · rw [hf.to_is_monoid_hom.map_one]
         apply IsSubmonoid.one_mem (closure.is_subgroup _).to_isSubmonoid
       · rw [hf.map_inv]
-        apply IsSubgroup.inv_mem (closure.is_subgroup _)
-        assumption
+        apply IsSubgroup.inv_mem (closure.is_subgroup _); assumption
       · rw [hf.to_is_monoid_hom.map_mul]
         solve_by_elim [IsSubmonoid.mul_mem (closure.is_subgroup _).to_isSubmonoid] )
     (closure_subset (hf.image_subgroup <| closure.isSubgroup _) <|

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

@@ -151,28 +151,28 @@ theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ :
 #align is_subgroup.inter IsSubgroup.inter
 #align is_add_subgroup.inter IsAddSubgroup.inter
 
-#print IsSubgroup.interᵢ /-
+#print IsSubgroup.iInter /-
 @[to_additive]
-theorem IsSubgroup.interᵢ {ι : Sort _} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
-    IsSubgroup (Set.interᵢ s) :=
-  { IsSubmonoid.interᵢ fun y => (hs y).to_isSubmonoid with
+theorem IsSubgroup.iInter {ι : Sort _} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
+    IsSubgroup (Set.iInter s) :=
+  { IsSubmonoid.iInter fun y => (hs y).to_isSubmonoid with
     inv_mem := fun x h =>
-      Set.mem_interᵢ.2 fun y => IsSubgroup.inv_mem (hs _) (Set.mem_interᵢ.1 h y) }
-#align is_subgroup.Inter IsSubgroup.interᵢ
-#align is_add_subgroup.Inter IsAddSubgroup.interᵢ
+      Set.mem_iInter.2 fun y => IsSubgroup.inv_mem (hs _) (Set.mem_iInter.1 h y) }
+#align is_subgroup.Inter IsSubgroup.iInter
+#align is_add_subgroup.Inter IsAddSubgroup.iInter
 -/
 
-#print isSubgroup_unionᵢ_of_directed /-
+#print isSubgroup_iUnion_of_directed /-
 @[to_additive]
-theorem isSubgroup_unionᵢ_of_directed {ι : Type _} [hι : Nonempty ι] {s : ι → Set G}
+theorem isSubgroup_iUnion_of_directed {ι : Type _} [hι : Nonempty ι] {s : ι → Set G}
     (hs : ∀ i, IsSubgroup (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
     IsSubgroup (⋃ i, s i) :=
   { inv_mem := fun a ha =>
-      let ⟨i, hi⟩ := Set.mem_unionᵢ.1 ha
-      Set.mem_unionᵢ.2 ⟨i, (hs i).inv_mem hi⟩
-    to_isSubmonoid := isSubmonoid_unionᵢ_of_directed (fun i => (hs i).to_isSubmonoid) Directed }
-#align is_subgroup_Union_of_directed isSubgroup_unionᵢ_of_directed
-#align is_add_subgroup_Union_of_directed isAddSubgroup_unionᵢ_of_directed
+      let ⟨i, hi⟩ := Set.mem_iUnion.1 ha
+      Set.mem_iUnion.2 ⟨i, (hs i).inv_mem hi⟩
+    to_isSubmonoid := isSubmonoid_iUnion_of_directed (fun i => (hs i).to_isSubmonoid) Directed }
+#align is_subgroup_Union_of_directed isSubgroup_iUnion_of_directed
+#align is_add_subgroup_Union_of_directed isAddSubgroup_iUnion_of_directed
 -/
 
 end Group
@@ -970,7 +970,7 @@ theorem conjugatesOf_subset {t : Set G} (ht : IsNormalSubgroup t) {a : G} (h : a
 #print Group.conjugatesOfSet_subset' /-
 theorem conjugatesOfSet_subset' {s t : Set G} (ht : IsNormalSubgroup t) (h : s ⊆ t) :
     conjugatesOfSet s ⊆ t :=
-  Set.unionᵢ₂_subset fun x H => conjugatesOf_subset ht (h H)
+  Set.iUnion₂_subset fun x H => conjugatesOf_subset ht (h H)
 #align group.conjugates_of_set_subset' Group.conjugatesOfSet_subset'
 -/
 

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

@@ -830,7 +830,7 @@ theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
     ⟨[], List.forall_mem_nil _, rfl⟩
     (fun x _ ⟨L, HL1, HL2⟩ =>
       ⟨L.reverse.map Inv.inv, fun x hx =>
-        let ⟨y, hy1, hy2⟩ := List.exists_of_mem_map' hx
+        let ⟨y, hy1, hy2⟩ := List.exists_of_mem_map hx
         hy2 ▸ Or.imp id (by rw [inv_inv] <;> exact id) (HL1 _ <| List.mem_reverse'.1 hy1).symm,
         HL2 ▸
           List.recOn L inv_one.symm fun hd tl ih => by

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

Also do the same for "/-A". This is a purely aesthetic change (and exhaustive).

@@ -673,7 +673,7 @@ theorem trivial_eq_closure : trivial G = Group.closure ∅ :=
 
 end IsSubgroup
 
-/-The normal closure of a set s is the subgroup closure of all the conjugates of
+/- The normal closure of a set s is the subgroup closure of all the conjugates of
 elements of s. It is the smallest normal subgroup containing s. -/
 namespace Group
 

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".

@@ -185,7 +185,7 @@ theorem Additive.isNormalAddSubgroup [Group G] {s : Set G} (hs : IsNormalSubgrou
     @IsNormalAddSubgroup (Additive G) _ s :=
   @IsNormalAddSubgroup.mk (Additive G) _ _ (Additive.isAddSubgroup hs.toIsSubgroup)
     (@IsNormalSubgroup.normal _ ‹Group (Additive G)› _ hs)
-    -- porting note: Lean needs help synthesising
+    -- Porting note: Lean needs help synthesising
 #align additive.is_normal_add_subgroup Additive.isNormalAddSubgroup
 
 theorem Additive.isNormalAddSubgroup_iff [Group G] {s : Set G} :

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

This has nice performance benefits.

@@ -34,7 +34,7 @@ subgroup, subgroups, IsSubgroup
 
 open Set Function
 
-variable {G : Type _} {H : Type _} {A : Type _} {a a₁ a₂ b c : G}
+variable {G : Type*} {H : Type*} {A : Type*} {a a₁ a₂ b c : G}
 
 section Group
 
@@ -110,7 +110,7 @@ theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ :
 #align is_add_subgroup.inter IsAddSubgroup.inter
 
 @[to_additive]
-theorem IsSubgroup.iInter {ι : Sort _} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
+theorem IsSubgroup.iInter {ι : Sort*} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
     IsSubgroup (Set.iInter s) :=
   { IsSubmonoid.iInter fun y => (hs y).toIsSubmonoid with
     inv_mem := fun h =>
@@ -119,7 +119,7 @@ theorem IsSubgroup.iInter {ι : Sort _} {s : ι → Set G} (hs : ∀ y : ι, IsS
 #align is_add_subgroup.Inter IsAddSubgroup.iInter
 
 @[to_additive]
-theorem isSubgroup_iUnion_of_directed {ι : Type _} [Nonempty ι] {s : ι → Set G}
+theorem isSubgroup_iUnion_of_directed {ι : Type*} [Nonempty ι] {s : ι → Set G}
     (hs : ∀ i, IsSubgroup (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
     IsSubgroup (⋃ i, s i) :=
   { inv_mem := fun ha =>
@@ -229,7 +229,7 @@ theorem mem_norm_comm_iff {s : Set G} (hs : IsNormalSubgroup s) {a b : G} : a *
 
 /-- The trivial subgroup -/
 @[to_additive "the trivial additive subgroup"]
-def trivial (G : Type _) [Group G] : Set G :=
+def trivial (G : Type*) [Group G] : Set G :=
   {1}
 #align is_subgroup.trivial IsSubgroup.trivial
 #align is_add_subgroup.trivial IsAddSubgroup.trivial
@@ -260,7 +260,7 @@ theorem univ_subgroup : IsNormalSubgroup (@univ G) := by refine' { .. } <;> simp
 
 /-- The underlying set of the center of a group. -/
 @[to_additive addCenter "The underlying set of the center of an additive group."]
-def center (G : Type _) [Group G] : Set G :=
+def center (G : Type*) [Group G] : Set G :=
   { z | ∀ g, g * z = z * g }
 #align is_subgroup.center IsSubgroup.center
 #align is_add_subgroup.add_center IsAddSubgroup.addCenter
@@ -645,7 +645,7 @@ theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.
 #align add_group.closure_eq_mclosure AddGroup.closure_eq_mclosure
 
 @[to_additive]
-theorem mem_closure_union_iff {G : Type _} [CommGroup G] {s t : Set G} {x : G} :
+theorem mem_closure_union_iff {G : Type*} [CommGroup G] {s t : Set G} {x : G} :
     x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x := by
   simp only [closure_eq_mclosure, Monoid.mem_closure_union_iff, exists_prop, preimage_union];
   constructor

@@ -325,7 +325,7 @@ namespace IsGroupHom
 open IsSubmonoid IsSubgroup
 
 /-- `ker f : Set G` is the underlying subset of the kernel of a map `G → H`. -/
-@[to_additive "`ker f : set A` is the underlying subset of the kernel of a map `A → B`"]
+@[to_additive "`ker f : Set A` is the underlying subset of the kernel of a map `A → B`"]
 def ker [Group H] (f : G → H) : Set G :=
   preimage f (trivial H)
 #align is_group_hom.ker IsGroupHom.ker
@@ -745,7 +745,7 @@ theorem normalClosure_mono {s t : Set G} : s ⊆ t → normalClosure s ⊆ norma
 end Group
 
 /-- Create a bundled subgroup from a set `s` and `[IsSubgroup s]`. -/
-@[to_additive "Create a bundled additive subgroup from a set `s` and `[is_add_subgroup s]`."]
+@[to_additive "Create a bundled additive subgroup from a set `s` and `[IsAddSubgroup s]`."]
 def Subgroup.of [Group G] {s : Set G} (h : IsSubgroup s) : Subgroup G
     where
   carrier := s

Various adaptations to changes when Fin API was moved to Std. One notable change is that many lemmas are now stated in terms of i ≠ 0 (for i : Fin n) rather then i.1 ≠ 0, and as a consequence many Fin.vne_of_ne applications have been added or removed, mostly removed.

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

@@ -574,7 +574,7 @@ theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
     (fun {x} _ ⟨L, HL1, HL2⟩ =>
       ⟨L.reverse.map Inv.inv, fun x hx =>
         let ⟨y, hy1, hy2⟩ := List.exists_of_mem_map hx
-        hy2 ▸ Or.imp id (by rw [inv_inv]; exact id) (HL1 _ <| List.mem_reverse'.1 hy1).symm,
+        hy2 ▸ Or.imp id (by rw [inv_inv]; exact id) (HL1 _ <| List.mem_reverse.1 hy1).symm,
         HL2 ▸
           List.recOn L inv_one.symm fun hd tl ih => by
             rw [List.reverse_cons, List.map_append, List.prod_append, ih, List.map_singleton,

• depends on: #5966

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

@@ -3,15 +3,12 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Mitchell Rowett, Scott Morrison, Johan Commelin, Mario Carneiro,
   Michael Howes
-
-! This file was ported from Lean 3 source module deprecated.subgroup
-! leanprover-community/mathlib commit f93c11933efbc3c2f0299e47b8ff83e9b539cbf6
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.GroupTheory.Subgroup.Basic
 import Mathlib.Deprecated.Submonoid
 
+#align_import deprecated.subgroup from "leanprover-community/mathlib"@"f93c11933efbc3c2f0299e47b8ff83e9b539cbf6"
+
 /-!
 # Unbundled subgroups (deprecated)
 

Run codespell Mathlib and keep some suggestions.

@@ -516,7 +516,8 @@ inductive InClosure (s : Set G) : G → Prop
   | mul {a b : G} : InClosure s a → InClosure s b → InClosure s (a * b)
 #align group.in_closure Group.InClosure
 
-/-- `Group.closure s` is the subgroup generated by `s`, i.e. the smallest subgroup containg `s`. -/
+/-- `Group.closure s` is the subgroup generated by `s`, i.e. the smallest subgroup containing `s`.
+-/
 @[to_additive
   "`AddGroup.closure s` is the additive subgroup generated by `s`, i.e., the
   smallest additive subgroup containing `s`."]

• Run a non-interactive version of fix-comments.py on all files.
• Go through the diff and manually add/discard/edit chunks.

@@ -327,7 +327,7 @@ namespace IsGroupHom
 
 open IsSubmonoid IsSubgroup
 
-/-- `ker f : set G` is the underlying subset of the kernel of a map `G → H`. -/
+/-- `ker f : Set G` is the underlying subset of the kernel of a map `G → H`. -/
 @[to_additive "`ker f : set A` is the underlying subset of the kernel of a map `A → B`"]
 def ker [Group H] (f : G → H) : Set G :=
   preimage f (trivial H)

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>

@@ -113,24 +113,24 @@ theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ :
 #align is_add_subgroup.inter IsAddSubgroup.inter
 
 @[to_additive]
-theorem IsSubgroup.interᵢ {ι : Sort _} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
-    IsSubgroup (Set.interᵢ s) :=
-  { IsSubmonoid.interᵢ fun y => (hs y).toIsSubmonoid with
+theorem IsSubgroup.iInter {ι : Sort _} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
+    IsSubgroup (Set.iInter s) :=
+  { IsSubmonoid.iInter fun y => (hs y).toIsSubmonoid with
     inv_mem := fun h =>
-      Set.mem_interᵢ.2 fun y => IsSubgroup.inv_mem (hs _) (Set.mem_interᵢ.1 h y) }
-#align is_subgroup.Inter IsSubgroup.interᵢ
-#align is_add_subgroup.Inter IsAddSubgroup.interᵢ
+      Set.mem_iInter.2 fun y => IsSubgroup.inv_mem (hs _) (Set.mem_iInter.1 h y) }
+#align is_subgroup.Inter IsSubgroup.iInter
+#align is_add_subgroup.Inter IsAddSubgroup.iInter
 
 @[to_additive]
-theorem isSubgroup_unionᵢ_of_directed {ι : Type _} [Nonempty ι] {s : ι → Set G}
+theorem isSubgroup_iUnion_of_directed {ι : Type _} [Nonempty ι] {s : ι → Set G}
     (hs : ∀ i, IsSubgroup (s i)) (directed : ∀ i j, ∃ k, s i ⊆ s k ∧ s j ⊆ s k) :
     IsSubgroup (⋃ i, s i) :=
   { inv_mem := fun ha =>
-      let ⟨i, hi⟩ := Set.mem_unionᵢ.1 ha
-      Set.mem_unionᵢ.2 ⟨i, (hs i).inv_mem hi⟩
-    toIsSubmonoid := isSubmonoid_unionᵢ_of_directed (fun i => (hs i).toIsSubmonoid) directed }
-#align is_subgroup_Union_of_directed isSubgroup_unionᵢ_of_directed
-#align is_add_subgroup_Union_of_directed isAddSubgroup_unionᵢ_of_directed
+      let ⟨i, hi⟩ := Set.mem_iUnion.1 ha
+      Set.mem_iUnion.2 ⟨i, (hs i).inv_mem hi⟩
+    toIsSubmonoid := isSubmonoid_iUnion_of_directed (fun i => (hs i).toIsSubmonoid) directed }
+#align is_subgroup_Union_of_directed isSubgroup_iUnion_of_directed
+#align is_add_subgroup_Union_of_directed isAddSubgroup_iUnion_of_directed
 
 end Group
 
@@ -690,7 +690,7 @@ theorem conjugatesOf_subset {t : Set G} (ht : IsNormalSubgroup t) {a : G} (h : a
 
 theorem conjugatesOfSet_subset' {s t : Set G} (ht : IsNormalSubgroup t) (h : s ⊆ t) :
     conjugatesOfSet s ⊆ t :=
-  Set.unionᵢ₂_subset fun _ H => conjugatesOf_subset ht (h H)
+  Set.iUnion₂_subset fun _ H => conjugatesOf_subset ht (h H)
 #align group.conjugates_of_set_subset' Group.conjugatesOfSet_subset'
 
 /-- The normal closure of a set s is the subgroup closure of all the conjugates of

This PR puts, with one exception, every single remaining by that lies all by itself on its own line to the previous line, thus matching the current behaviour of start-port.sh. The exception is when the by begins the second or later argument to a tuple or anonymous constructor; see https://github.com/leanprover-community/mathlib4/pull/3825#discussion_r1186702599.

Essentially this is s/\n *by$/ by/g, but with manual editing to satisfy the linter's max-100-char-line requirement. The Python style linter is also modified to catch these "isolated bys".

@@ -343,16 +343,16 @@ theorem mem_ker [Group H] (f : G → H) {x : G} : x ∈ ker f ↔ f x = 1 :=
 variable [Group G] [Group H]
 
 @[to_additive]
-theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) : f a = f b :=
-  by
+theorem one_ker_inv {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a * b⁻¹) = 1) :
+    f a = f b := by
   rw [hf.map_mul, hf.map_inv] at h
   rw [← inv_inv (f b), eq_inv_of_mul_eq_one_left h]
 #align is_group_hom.one_ker_inv IsGroupHom.one_ker_inv
 #align is_add_group_hom.zero_ker_neg IsAddGroupHom.zero_ker_neg
 
 @[to_additive]
-theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) : f a = f b :=
-  by
+theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹ * b) = 1) :
+    f a = f b := by
   rw [hf.map_mul, hf.map_inv] at h
   apply inv_injective
   rw [eq_inv_of_mul_eq_one_left h]
@@ -360,16 +360,16 @@ theorem one_ker_inv' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f (a⁻¹
 #align is_add_group_hom.zero_ker_neg' IsAddGroupHom.zero_ker_neg'
 
 @[to_additive]
-theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a * b⁻¹) = 1 :=
-  by
+theorem inv_ker_one {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) :
+    f (a * b⁻¹) = 1 := by
   have : f a * (f b)⁻¹ = 1 := by rw [h, mul_right_inv]
   rwa [← hf.map_inv, ← hf.map_mul] at this
 #align is_group_hom.inv_ker_one IsGroupHom.inv_ker_one
 #align is_add_group_hom.neg_ker_zero IsAddGroupHom.neg_ker_zero
 
 @[to_additive]
-theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) : f (a⁻¹ * b) = 1 :=
-  by
+theorem inv_ker_one' {f : G → H} (hf : IsGroupHom f) {a b : G} (h : f a = f b) :
+    f (a⁻¹ * b) = 1 := by
   have : (f a)⁻¹ * f b = 1 := by rw [h, mul_left_inv]
   rwa [← hf.map_inv, ← hf.map_mul] at this
 #align is_group_hom.inv_ker_one' IsGroupHom.inv_ker_one'
@@ -648,8 +648,7 @@ theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.
 
 @[to_additive]
 theorem mem_closure_union_iff {G : Type _} [CommGroup G] {s t : Set G} {x : G} :
-    x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x :=
-  by
+    x ∈ closure (s ∪ t) ↔ ∃ y ∈ closure s, ∃ z ∈ closure t, y * z = x := by
   simp only [closure_eq_mclosure, Monoid.mem_closure_union_iff, exists_prop, preimage_union];
   constructor
   · rintro ⟨_, ⟨ys, hys, yt, hyt, rfl⟩, _, ⟨zs, hzs, zt, hzt, rfl⟩, rfl⟩
@@ -683,8 +682,7 @@ namespace Group
 variable {s : Set G} [Group G]
 
 theorem conjugatesOf_subset {t : Set G} (ht : IsNormalSubgroup t) {a : G} (h : a ∈ t) :
-    conjugatesOf a ⊆ t := fun x hc =>
-  by
+    conjugatesOf a ⊆ t := fun x hc => by
   obtain ⟨c, w⟩ := isConj_iff.1 hc
   have H := IsNormalSubgroup.normal ht a h c
   rwa [← w]
@@ -729,8 +727,7 @@ theorem normalClosure.is_normal : IsNormalSubgroup (normalClosure s) :=
 
 /-- The normal closure of s is the smallest normal subgroup containing s. -/
 theorem normalClosure_subset {s t : Set G} (ht : IsNormalSubgroup t) (h : s ⊆ t) :
-    normalClosure s ⊆ t := fun a w =>
-  by
+    normalClosure s ⊆ t := fun a w => by
   induction' w with x hx x _ ihx x y _ _ ihx ihy
   · exact conjugatesOfSet_subset' ht h <| hx
   · exact ht.toIsSubgroup.toIsSubmonoid.one_mem

Notably incorporates https://github.com/leanprover/std4/pull/98 and https://github.com/leanprover/std4/pull/109.

https://github.com/leanprover/std4/pull/98 moves a number of lemmas from Mathlib to Std, so the bump requires deleting them in Mathlib. I did check on each lemma whether its attributes were kept in the move (and gave attribute markings in Mathlib if they were not present in Std), but a reviewer may wish to re-check.

List.mem_map changed statement from b ∈ l.map f ↔ ∃ a, a ∈ l ∧ b = f a to b ∈ l.map f ↔ ∃ a, a ∈ l ∧ f a = b. Similarly for List.exists_of_mem_map. This was a deliberate change, so I have simply adjusted proofs (many become simpler, which supports the change). I also deleted List.mem_map', List.exists_of_mem_map', which were temporary versions in Mathlib while waiting for this change (replacing their uses with the unprimed versions).

Also, the lemma sublist_nil_iff_eq_nil seems to have been renamed to sublist_nil during the move, so I added an alias for the old name.

(another issue fixed during review by @digama0) List.Sublist.filter had an argument change from explicit to implicit. This appears to have been an oversight (cc @JamesGallicchio). I have temporarily introduced List.Sublist.filter' with the argument explicit, and replaced Mathlib uses of Sublist.filter with Sublist.filter'. Later we can fix the argument in Std, and then delete List.Sublist.filter'.

@@ -575,7 +575,7 @@ theorem exists_list_of_mem_closure {s : Set G} {a : G} (h : a ∈ closure s) :
     ⟨[], List.forall_mem_nil _, rfl⟩
     (fun {x} _ ⟨L, HL1, HL2⟩ =>
       ⟨L.reverse.map Inv.inv, fun x hx =>
-        let ⟨y, hy1, hy2⟩ := List.exists_of_mem_map' hx
+        let ⟨y, hy1, hy2⟩ := List.exists_of_mem_map hx
         hy2 ▸ Or.imp id (by rw [inv_inv]; exact id) (HL1 _ <| List.mem_reverse'.1 hy1).symm,
         HL2 ▸
           List.recOn L inv_one.symm fun hd tl ih => by

• There is now configuration for congr!, convert, and convert_to to control parts of the congruence algorithm, in particular transparency settings when applying congruence lemmas.
• congr! now applies congruence lemmas with reducible transparency by default. This prevents it from unfolding definitions when applying congruence lemmas. It also now tries both the LHS-biased and RHS-biased simp congruence lemmas, with a configuration option to set which it should try first.
• There is now a new HEq congruence lemma generator that gives each hypothesis access to the proofs of previous hypotheses. This means that if you have an equality ⊢ ⟨a, x⟩ = ⟨b, y⟩ of sigma types, congr! turns this into goals ⊢ a = b and ⊢ a = b → HEq x y (note that congr! will also auto-introduce a = b for you in the second goal). This congruence lemma generator applies to more cases than the simp congruence lemma generator does.
• congr! (and hence convert) are more careful about applying lemmas that don't force definitions to unfold. There were a number of cases in mathlib where the implementation of congr was being abused to unfold definitions.
• With set_option trace.congr! true you can see what congr! sees when it is deciding on congruence lemmas.
• There is also a bug fix in convert_to to do using 1 when there is no using clause, to match its documentation.

Note that congr! is more capable than congr at finding a way to equate left-hand sides and right-hand sides, so you will frequently need to limit its depth with a using clause. However, there is also a new heuristic to prevent considering unlikely-to-be-provable type equalities (controlled by the typeEqs option), which can help limit the depth automatically.

There is also a predefined configuration that you can invoke with, for example, convert (config := .unfoldSameFun) h, that causes it to behave more like congr, including using default transparency when unfolding.

@@ -87,7 +87,7 @@ theorem IsSubgroup.of_div (s : Set G) (one_mem : (1 : G) ∈ s)
     (div_mem : ∀ {a b : G}, a ∈ s → b ∈ s → a * b⁻¹ ∈ s) : IsSubgroup s :=
   have inv_mem : ∀ a, a ∈ s → a⁻¹ ∈ s := fun a ha => by
     have : 1 * a⁻¹ ∈ s := div_mem one_mem ha
-    convert this
+    convert this using 1
     rw [one_mul]
   { inv_mem := inv_mem _
     mul_mem := fun {a b} ha hb => by

@@ -115,7 +115,7 @@ theorem IsSubgroup.inter {s₁ s₂ : Set G} (hs₁ : IsSubgroup s₁) (hs₂ :
 @[to_additive]
 theorem IsSubgroup.interᵢ {ι : Sort _} {s : ι → Set G} (hs : ∀ y : ι, IsSubgroup (s y)) :
     IsSubgroup (Set.interᵢ s) :=
-  { IsSubmonoid.Inter fun y => (hs y).toIsSubmonoid with
+  { IsSubmonoid.interᵢ fun y => (hs y).toIsSubmonoid with
     inv_mem := fun h =>
       Set.mem_interᵢ.2 fun y => IsSubgroup.inv_mem (hs _) (Set.mem_interᵢ.1 h y) }
 #align is_subgroup.Inter IsSubgroup.interᵢ
@@ -128,7 +128,7 @@ theorem isSubgroup_unionᵢ_of_directed {ι : Type _} [Nonempty ι] {s : ι →
   { inv_mem := fun ha =>
       let ⟨i, hi⟩ := Set.mem_unionᵢ.1 ha
       Set.mem_unionᵢ.2 ⟨i, (hs i).inv_mem hi⟩
-    toIsSubmonoid := is_submonoid_Union_of_directed (fun i => (hs i).toIsSubmonoid) directed }
+    toIsSubmonoid := isSubmonoid_unionᵢ_of_directed (fun i => (hs i).toIsSubmonoid) directed }
 #align is_subgroup_Union_of_directed isSubgroup_unionᵢ_of_directed
 #align is_add_subgroup_Union_of_directed isAddSubgroup_unionᵢ_of_directed
 
@@ -292,10 +292,10 @@ theorem center_normal : IsNormalSubgroup (center G) :=
 #align is_subgroup.center_normal IsSubgroup.center_normal
 #align is_add_subgroup.add_center_normal IsAddSubgroup.add_center_normal
 
-/-- The underlying set of the normalizer of a subset `S : set G` of a group `G`. That is,
+/-- The underlying set of the normalizer of a subset `S : Set G` of a group `G`. That is,
   the elements `g : G` such that `g * S * g⁻¹ = S`. -/
 @[to_additive addNormalizer
-      "The underlying set of the normalizer of a subset `S : set A` of an
+      "The underlying set of the normalizer of a subset `S : Set A` of an
       additive group `A`. That is, the elements `a : A` such that `a + S - a = S`."]
 def normalizer (s : Set G) : Set G :=
   { g : G | ∀ n, n ∈ s ↔ g * n * g⁻¹ ∈ s }
@@ -627,8 +627,8 @@ theorem mclosure_inv_subset {s : Set G} : Monoid.Closure (Inv.inv ⁻¹' s) ⊆
 theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.inv ⁻¹' s) :=
   Set.Subset.antisymm
     (@closure_subset _ _ _ (Monoid.Closure (s ∪ Inv.inv ⁻¹' s))
-      { one_mem := (Monoid.closure.IsSubmonoid _).one_mem
-        mul_mem := (Monoid.closure.IsSubmonoid _).mul_mem
+      { one_mem := (Monoid.closure.isSubmonoid _).one_mem
+        mul_mem := (Monoid.closure.isSubmonoid _).mul_mem
         inv_mem := fun hx =>
           Monoid.InClosure.recOn hx
             (fun {x} hx =>
@@ -636,9 +636,9 @@ theorem closure_eq_mclosure {s : Set G} : closure s = Monoid.Closure (s ∪ Inv.
                 (fun hx =>
                   Monoid.subset_closure <| Or.inr <| show x⁻¹⁻¹ ∈ s from (inv_inv x).symm ▸ hx)
                 fun hx => Monoid.subset_closure <| Or.inl hx)
-            ((@inv_one G _).symm ▸ IsSubmonoid.one_mem (Monoid.closure.IsSubmonoid _))
+            ((@inv_one G _).symm ▸ IsSubmonoid.one_mem (Monoid.closure.isSubmonoid _))
             fun {x y} _ _ ihx ihy =>
-            (mul_inv_rev x y).symm ▸ IsSubmonoid.mul_mem (Monoid.closure.IsSubmonoid _) ihy ihx }
+            (mul_inv_rev x y).symm ▸ IsSubmonoid.mul_mem (Monoid.closure.isSubmonoid _) ihy ihx }
       (Set.Subset.trans (Set.subset_union_left _ _) Monoid.subset_closure))
     (Monoid.closure_subset (closure.isSubgroup _).toIsSubmonoid <|
       Set.union_subset subset_closure fun x hx =>