group_theory.finiteness ⟷ Mathlib.GroupTheory.Finiteness

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

@@ -176,7 +176,10 @@ end Monoid
 #print Submonoid.FG.map /-
 @[to_additive]
 theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
-    (P.map e).FG := by classical
+    (P.map e).FG := by
+  classical
+  obtain ⟨s, rfl⟩ := h
+  exact ⟨s.image e, by rw [Finset.coe_image, MonoidHom.map_mclosure]⟩
 #align submonoid.fg.map Submonoid.FG.map
 #align add_submonoid.fg.map AddSubmonoid.FG.map
 -/
@@ -210,7 +213,12 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
 #print Monoid.fg_of_surjective /-
 @[to_additive]
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
-    (hf : Function.Surjective f) : Monoid.FG M' := by classical
+    (hf : Function.Surjective f) : Monoid.FG M' := by
+  classical
+  obtain ⟨s, hs⟩ := monoid.fg_def.mp ‹_›
+  use s.image f
+  rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
+    MonoidHom.mrange_top_iff_surjective]
 #align monoid.fg_of_surjective Monoid.fg_of_surjective
 #align add_monoid.fg_of_surjective AddMonoid.fg_of_surjective
 -/
@@ -501,7 +509,13 @@ variable {G} {G' : Type _} [Group G']
 #print Group.rank_le_of_surjective /-
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
-    (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by classical
+    (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by
+  classical
+  obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
+  trans (S.image f).card
+  · apply Group.rank_le
+    rw [Finset.coe_image, ← MonoidHom.map_closure, hS2, Subgroup.map_top_of_surjective f hf]
+  · exact finset.card_image_le.trans_eq hS1
 #align group.rank_le_of_surjective Group.rank_le_of_surjective
 #align add_group.rank_le_of_surjective AddGroup.rank_le_of_surjective
 -/
@@ -539,6 +553,15 @@ theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
 @[to_additive]
 theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card := by
   classical
+  let t : Finset (closure (s : Set G)) := s.preimage coe (subtype.coe_injective.inj_on _)
+  have ht : closure (t : Set (closure (s : Set G))) = ⊤ :=
+    by
+    rw [Finset.coe_preimage]
+    exact closure_preimage_eq_top s
+  apply (Group.rank_le (closure (s : Set G)) ht).trans
+  rw [← Finset.card_image_of_injOn, Finset.image_preimage]
+  · apply Finset.card_filter_le
+  · apply subtype.coe_injective.inj_on
 #align subgroup.rank_closure_finset_le_card Subgroup.rank_closure_finset_le_card
 #align add_subgroup.rank_closure_finset_le_card AddSubgroup.rank_closure_finset_le_card
 -/

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

@@ -176,10 +176,7 @@ end Monoid
 #print Submonoid.FG.map /-
 @[to_additive]
 theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
-    (P.map e).FG := by
-  classical
-  obtain ⟨s, rfl⟩ := h
-  exact ⟨s.image e, by rw [Finset.coe_image, MonoidHom.map_mclosure]⟩
+    (P.map e).FG := by classical
 #align submonoid.fg.map Submonoid.FG.map
 #align add_submonoid.fg.map AddSubmonoid.FG.map
 -/
@@ -213,12 +210,7 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
 #print Monoid.fg_of_surjective /-
 @[to_additive]
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
-    (hf : Function.Surjective f) : Monoid.FG M' := by
-  classical
-  obtain ⟨s, hs⟩ := monoid.fg_def.mp ‹_›
-  use s.image f
-  rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
-    MonoidHom.mrange_top_iff_surjective]
+    (hf : Function.Surjective f) : Monoid.FG M' := by classical
 #align monoid.fg_of_surjective Monoid.fg_of_surjective
 #align add_monoid.fg_of_surjective AddMonoid.fg_of_surjective
 -/
@@ -509,13 +501,7 @@ variable {G} {G' : Type _} [Group G']
 #print Group.rank_le_of_surjective /-
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
-    (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by
-  classical
-  obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
-  trans (S.image f).card
-  · apply Group.rank_le
-    rw [Finset.coe_image, ← MonoidHom.map_closure, hS2, Subgroup.map_top_of_surjective f hf]
-  · exact finset.card_image_le.trans_eq hS1
+    (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by classical
 #align group.rank_le_of_surjective Group.rank_le_of_surjective
 #align add_group.rank_le_of_surjective AddGroup.rank_le_of_surjective
 -/
@@ -553,15 +539,6 @@ theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
 @[to_additive]
 theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card := by
   classical
-  let t : Finset (closure (s : Set G)) := s.preimage coe (subtype.coe_injective.inj_on _)
-  have ht : closure (t : Set (closure (s : Set G))) = ⊤ :=
-    by
-    rw [Finset.coe_preimage]
-    exact closure_preimage_eq_top s
-  apply (Group.rank_le (closure (s : Set G)) ht).trans
-  rw [← Finset.card_image_of_injOn, Finset.image_preimage]
-  · apply Finset.card_filter_le
-  · apply subtype.coe_injective.inj_on
 #align subgroup.rank_closure_finset_le_card Subgroup.rank_closure_finset_le_card
 #align add_subgroup.rank_closure_finset_le_card AddSubgroup.rank_closure_finset_le_card
 -/

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

@@ -3,12 +3,12 @@ Copyright (c) 2021 Riccardo Brasca. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Riccardo Brasca
 -/
-import Mathbin.Data.Set.Pointwise.Finite
-import Mathbin.GroupTheory.QuotientGroup
-import Mathbin.GroupTheory.Submonoid.Operations
-import Mathbin.GroupTheory.Subgroup.Basic
-import Mathbin.SetTheory.Cardinal.Finite
-import Mathbin.Data.Finset.Preimage
+import Data.Set.Pointwise.Finite
+import GroupTheory.QuotientGroup
+import GroupTheory.Submonoid.Operations
+import GroupTheory.Subgroup.Basic
+import SetTheory.Cardinal.Finite
+import Data.Finset.Preimage
 
 #align_import group_theory.finiteness from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
 

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Riccardo Brasca. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Riccardo Brasca
-
-! This file was ported from Lean 3 source module group_theory.finiteness
-! leanprover-community/mathlib commit 34ee86e6a59d911a8e4f89b68793ee7577ae79c7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Pointwise.Finite
 import Mathbin.GroupTheory.QuotientGroup
@@ -15,6 +10,8 @@ import Mathbin.GroupTheory.Subgroup.Basic
 import Mathbin.SetTheory.Cardinal.Finite
 import Mathbin.Data.Finset.Preimage
 
+#align_import group_theory.finiteness from "leanprover-community/mathlib"@"34ee86e6a59d911a8e4f89b68793ee7577ae79c7"
+
 /-!
 # Finitely generated monoids and groups
 

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

@@ -70,6 +70,7 @@ theorem Submonoid.fg_iff (P : Submonoid M) :
 #align add_submonoid.fg_iff AddSubmonoid.fg_iff
 -/
 
+#print Submonoid.fg_iff_add_fg /-
 theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG :=
   ⟨fun h =>
     let ⟨S, hS, hf⟩ := (Submonoid.fg_iff _).1 h
@@ -80,12 +81,15 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG
     (Submonoid.fg_iff _).mpr
       ⟨Multiplicative.ofAdd ⁻¹' T, by simp [← AddSubmonoid.toSubmonoid'_closure, hT], hf⟩⟩
 #align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fg
+-/
 
+#print AddSubmonoid.fg_iff_mul_fg /-
 theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG :=
   by
   convert (Submonoid.fg_iff_add_fg P.to_submonoid).symm
   exact SetLike.ext' rfl
 #align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fg
+-/
 
 end Submonoid
 
@@ -112,14 +116,19 @@ attribute [to_additive] Monoid.FG
 
 variable {M N}
 
+#print Monoid.fg_def /-
 theorem Monoid.fg_def : Monoid.FG M ↔ (⊤ : Submonoid M).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align monoid.fg_def Monoid.fg_def
+-/
 
+#print AddMonoid.fg_def /-
 theorem AddMonoid.fg_def : AddMonoid.FG N ↔ (⊤ : AddSubmonoid N).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_monoid.fg_def AddMonoid.fg_def
+-/
 
+#print Monoid.fg_iff /-
 /-- An equivalent expression of `monoid.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_monoid.fg` in terms of `set.finite` instead of\n`finset`."]
@@ -128,6 +137,7 @@ theorem Monoid.fg_iff :
   ⟨fun h => (Submonoid.fg_iff ⊤).1 h.out, fun h => ⟨(Submonoid.fg_iff ⊤).2 h⟩⟩
 #align monoid.fg_iff Monoid.fg_iff
 #align add_monoid.fg_iff AddMonoid.fg_iff
+-/
 
 #print Monoid.fg_iff_add_fg /-
 theorem Monoid.fg_iff_add_fg : Monoid.FG M ↔ AddMonoid.FG (Additive M) :=
@@ -177,6 +187,7 @@ theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG)
 #align add_submonoid.fg.map AddSubmonoid.FG.map
 -/
 
+#print Submonoid.FG.map_injective /-
 @[to_additive]
 theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
     (he : Function.Injective e) (h : (P.map e).FG) : P.FG :=
@@ -190,7 +201,9 @@ theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (
   exact Submonoid.monotone_map le_top
 #align submonoid.fg.map_injective Submonoid.FG.map_injective
 #align add_submonoid.fg.map_injective AddSubmonoid.FG.map_injective
+-/
 
+#print Monoid.fg_iff_submonoid_fg /-
 @[simp, to_additive]
 theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
   by
@@ -198,7 +211,9 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
   exact ⟨fun h => h.out.map N.subtype, fun h => ⟨h.map_injective N.subtype Subtype.coe_injective⟩⟩
 #align monoid.fg_iff_submonoid_fg Monoid.fg_iff_submonoid_fg
 #align add_monoid.fg_iff_add_submonoid_fg AddMonoid.fg_iff_addSubmonoid_fg
+-/
 
+#print Monoid.fg_of_surjective /-
 @[to_additive]
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
     (hf : Function.Surjective f) : Monoid.FG M' := by
@@ -209,13 +224,16 @@ theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M 
     MonoidHom.mrange_top_iff_surjective]
 #align monoid.fg_of_surjective Monoid.fg_of_surjective
 #align add_monoid.fg_of_surjective AddMonoid.fg_of_surjective
+-/
 
+#print Monoid.fg_range /-
 @[to_additive]
 instance Monoid.fg_range {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M') :
     Monoid.FG f.mrange :=
   Monoid.fg_of_surjective f.mrangeRestrict f.mrangeRestrict_surjective
 #align monoid.fg_range Monoid.fg_range
 #align add_monoid.fg_range AddMonoid.fg_range
+-/
 
 #print Submonoid.powers_fg /-
 @[to_additive AddSubmonoid.multiples_fg]
@@ -225,12 +243,15 @@ theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG :=
 #align add_submonoid.multiples_fg AddSubmonoid.multiples_fg
 -/
 
+#print Monoid.powers_fg /-
 @[to_additive AddMonoid.multiples_fg]
 instance Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) :=
   (Monoid.fg_iff_submonoid_fg _).mpr (Submonoid.powers_fg r)
 #align monoid.powers_fg Monoid.powers_fg
 #align add_monoid.multiples_fg AddMonoid.multiples_fg
+-/
 
+#print Monoid.closure_finset_fg /-
 @[to_additive]
 instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure (s : Set M)) :=
   by
@@ -238,13 +259,16 @@ instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure
   rw [Finset.coe_preimage, Submonoid.closure_closure_coe_preimage]
 #align monoid.closure_finset_fg Monoid.closure_finset_fg
 #align add_monoid.closure_finset_fg AddMonoid.closure_finset_fg
+-/
 
+#print Monoid.closure_finite_fg /-
 @[to_additive]
 instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.closure s) :=
   haveI := Fintype.ofFinite s
   s.coe_to_finset ▸ Monoid.closure_finset_fg s.to_finset
 #align monoid.closure_finite_fg Monoid.closure_finite_fg
 #align add_monoid.closure_finite_fg AddMonoid.closure_finite_fg
+-/
 
 /-! ### Groups and subgroups -/
 
@@ -299,17 +323,21 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.F
 #align add_subgroup.fg_iff_add_submonoid.fg AddSubgroup.fg_iff_addSubmonoid_fg
 -/
 
+#print Subgroup.fg_iff_add_fg /-
 theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG :=
   by
   rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.fg_iff_addSubmonoid_fg]
   exact (Subgroup.toSubmonoid P).fg_iff_add_fg
 #align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fg
+-/
 
+#print AddSubgroup.fg_iff_mul_fg /-
 theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG :=
   by
   rw [AddSubgroup.fg_iff_addSubmonoid_fg, Subgroup.fg_iff_submonoid_fg]
   exact AddSubmonoid.fg_iff_mul_fg (AddSubgroup.toAddSubmonoid P)
 #align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fg
+-/
 
 end Subgroup
 
@@ -336,14 +364,19 @@ attribute [to_additive] Group.FG
 
 variable {G H}
 
+#print Group.fg_def /-
 theorem Group.fg_def : Group.FG G ↔ (⊤ : Subgroup G).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align group.fg_def Group.fg_def
+-/
 
+#print AddGroup.fg_def /-
 theorem AddGroup.fg_def : AddGroup.FG H ↔ (⊤ : AddSubgroup H).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_group.fg_def AddGroup.fg_def
+-/
 
+#print Group.fg_iff /-
 /-- An equivalent expression of `group.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_group.fg` in terms of `set.finite` instead of\n`finset`."]
@@ -351,13 +384,16 @@ theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ :
   ⟨fun h => (Subgroup.fg_iff ⊤).1 h.out, fun h => ⟨(Subgroup.fg_iff ⊤).2 h⟩⟩
 #align group.fg_iff Group.fg_iff
 #align add_group.fg_iff AddGroup.fg_iff
+-/
 
+#print Group.fg_iff' /-
 @[to_additive]
 theorem Group.fg_iff' :
     Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
   Group.fg_def.trans ⟨fun ⟨S, hS⟩ => ⟨S.card, S, rfl, hS⟩, fun ⟨n, S, hn, hS⟩ => ⟨S, hS⟩⟩
 #align group.fg_iff' Group.fg_iff'
 #align add_group.fg_iff' AddGroup.fg_iff'
+-/
 
 #print Group.fg_iff_monoid_fg /-
 /-- A group is finitely generated if and only if it is finitely generated as a monoid. -/
@@ -405,6 +441,7 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G :=
 #align add_group.fg_of_finite AddGroup.fg_of_finite
 -/
 
+#print Group.fg_of_surjective /-
 @[to_additive]
 theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G →* G'}
     (hf : Function.Surjective f) : Group.FG G' :=
@@ -412,13 +449,17 @@ theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G
     @Monoid.fg_of_surjective G _ G' _ (Group.fg_iff_monoid_fg.mp hG) f hf
 #align group.fg_of_surjective Group.fg_of_surjective
 #align add_group.fg_of_surjective AddGroup.fg_of_surjective
+-/
 
+#print Group.fg_range /-
 @[to_additive]
 instance Group.fg_range {G' : Type _} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range :=
   Group.fg_of_surjective f.rangeRestrict_surjective
 #align group.fg_range Group.fg_range
 #align add_group.fg_range AddGroup.fg_range
+-/
 
+#print Group.closure_finset_fg /-
 @[to_additive]
 instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s : Set G)) :=
   by
@@ -426,13 +467,16 @@ instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s
   rw [Finset.coe_preimage, ← Subgroup.coeSubtype, Subgroup.closure_preimage_eq_top]
 #align group.closure_finset_fg Group.closure_finset_fg
 #align add_group.closure_finset_fg AddGroup.closure_finset_fg
+-/
 
+#print Group.closure_finite_fg /-
 @[to_additive]
 instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.FG (Subgroup.closure s) :=
   haveI := Fintype.ofFinite s
   s.coe_to_finset ▸ Group.closure_finset_fg s.to_finset
 #align group.closure_finite_fg Group.closure_finite_fg
 #align add_group.closure_finite_fg AddGroup.closure_finite_fg
+-/
 
 variable (G)
 
@@ -445,22 +489,27 @@ noncomputable def Group.rank [h : Group.FG G] :=
 #align add_group.rank AddGroup.rank
 -/
 
+#print Group.rank_spec /-
 @[to_additive]
 theorem Group.rank_spec [h : Group.FG G] :
     ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ :=
   @Nat.find_spec _ (Classical.decPred _) (Group.fg_iff'.mp h)
 #align group.rank_spec Group.rank_spec
 #align add_group.rank_spec AddGroup.rank_spec
+-/
 
+#print Group.rank_le /-
 @[to_additive]
 theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
     Group.rank G ≤ S.card :=
   @Nat.find_le _ _ (Classical.decPred _) (Group.fg_iff'.mp h) ⟨S, rfl, hS⟩
 #align group.rank_le Group.rank_le
 #align add_group.rank_le AddGroup.rank_le
+-/
 
 variable {G} {G' : Type _} [Group G']
 
+#print Group.rank_le_of_surjective /-
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
     (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by
@@ -472,30 +521,38 @@ theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
   · exact finset.card_image_le.trans_eq hS1
 #align group.rank_le_of_surjective Group.rank_le_of_surjective
 #align add_group.rank_le_of_surjective AddGroup.rank_le_of_surjective
+-/
 
+#print Group.rank_range_le /-
 @[to_additive]
 theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G :=
   Group.rank_le_of_surjective f.range_restrict f.rangeRestrict_surjective
 #align group.rank_range_le Group.rank_range_le
 #align add_group.rank_range_le AddGroup.rank_range_le
+-/
 
+#print Group.rank_congr /-
 @[to_additive]
 theorem Group.rank_congr [Group.FG G] [Group.FG G'] (f : G ≃* G') : Group.rank G = Group.rank G' :=
   le_antisymm (Group.rank_le_of_surjective f.symm f.symm.Surjective)
     (Group.rank_le_of_surjective f f.Surjective)
 #align group.rank_congr Group.rank_congr
 #align add_group.rank_congr AddGroup.rank_congr
+-/
 
 end Group
 
 namespace Subgroup
 
+#print Subgroup.rank_congr /-
 @[to_additive]
 theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
     Group.rank H = Group.rank K := by subst h
 #align subgroup.rank_congr Subgroup.rank_congr
 #align add_subgroup.rank_congr AddSubgroup.rank_congr
+-/
 
+#print Subgroup.rank_closure_finset_le_card /-
 @[to_additive]
 theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card := by
   classical
@@ -510,7 +567,9 @@ theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Se
   · apply subtype.coe_injective.inj_on
 #align subgroup.rank_closure_finset_le_card Subgroup.rank_closure_finset_le_card
 #align add_subgroup.rank_closure_finset_le_card AddSubgroup.rank_closure_finset_le_card
+-/
 
+#print Subgroup.rank_closure_finite_le_nat_card /-
 @[to_additive]
 theorem rank_closure_finite_le_nat_card (s : Set G) [Finite s] :
     Group.rank (closure s) ≤ Nat.card s :=
@@ -520,6 +579,7 @@ theorem rank_closure_finite_le_nat_card (s : Set G) [Finite s] :
   exact rank_closure_finset_le_card s.to_finset
 #align subgroup.rank_closure_finite_le_nat_card Subgroup.rank_closure_finite_le_nat_card
 #align add_subgroup.rank_closure_finite_le_nat_card AddSubgroup.rank_closure_finite_le_nat_card
+-/
 
 end Subgroup
 

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

@@ -83,7 +83,7 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG
 
 theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG :=
   by
-  convert(Submonoid.fg_iff_add_fg P.to_submonoid).symm
+  convert (Submonoid.fg_iff_add_fg P.to_submonoid).symm
   exact SetLike.ext' rfl
 #align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fg
 
@@ -171,8 +171,8 @@ end Monoid
 theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
     (P.map e).FG := by
   classical
-    obtain ⟨s, rfl⟩ := h
-    exact ⟨s.image e, by rw [Finset.coe_image, MonoidHom.map_mclosure]⟩
+  obtain ⟨s, rfl⟩ := h
+  exact ⟨s.image e, by rw [Finset.coe_image, MonoidHom.map_mclosure]⟩
 #align submonoid.fg.map Submonoid.FG.map
 #align add_submonoid.fg.map AddSubmonoid.FG.map
 -/
@@ -203,10 +203,10 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
     (hf : Function.Surjective f) : Monoid.FG M' := by
   classical
-    obtain ⟨s, hs⟩ := monoid.fg_def.mp ‹_›
-    use s.image f
-    rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
-      MonoidHom.mrange_top_iff_surjective]
+  obtain ⟨s, hs⟩ := monoid.fg_def.mp ‹_›
+  use s.image f
+  rwa [Finset.coe_image, ← MonoidHom.map_mclosure, hs, ← MonoidHom.mrange_eq_map,
+    MonoidHom.mrange_top_iff_surjective]
 #align monoid.fg_of_surjective Monoid.fg_of_surjective
 #align add_monoid.fg_of_surjective AddMonoid.fg_of_surjective
 
@@ -465,11 +465,11 @@ variable {G} {G' : Type _} [Group G']
 theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
     (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by
   classical
-    obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
-    trans (S.image f).card
-    · apply Group.rank_le
-      rw [Finset.coe_image, ← MonoidHom.map_closure, hS2, Subgroup.map_top_of_surjective f hf]
-    · exact finset.card_image_le.trans_eq hS1
+  obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
+  trans (S.image f).card
+  · apply Group.rank_le
+    rw [Finset.coe_image, ← MonoidHom.map_closure, hS2, Subgroup.map_top_of_surjective f hf]
+  · exact finset.card_image_le.trans_eq hS1
 #align group.rank_le_of_surjective Group.rank_le_of_surjective
 #align add_group.rank_le_of_surjective AddGroup.rank_le_of_surjective
 
@@ -499,15 +499,15 @@ theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
 @[to_additive]
 theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card := by
   classical
-    let t : Finset (closure (s : Set G)) := s.preimage coe (subtype.coe_injective.inj_on _)
-    have ht : closure (t : Set (closure (s : Set G))) = ⊤ :=
-      by
-      rw [Finset.coe_preimage]
-      exact closure_preimage_eq_top s
-    apply (Group.rank_le (closure (s : Set G)) ht).trans
-    rw [← Finset.card_image_of_injOn, Finset.image_preimage]
-    · apply Finset.card_filter_le
-    · apply subtype.coe_injective.inj_on
+  let t : Finset (closure (s : Set G)) := s.preimage coe (subtype.coe_injective.inj_on _)
+  have ht : closure (t : Set (closure (s : Set G))) = ⊤ :=
+    by
+    rw [Finset.coe_preimage]
+    exact closure_preimage_eq_top s
+  apply (Group.rank_le (closure (s : Set G)) ht).trans
+  rw [← Finset.card_image_of_injOn, Finset.image_preimage]
+  · apply Finset.card_filter_le
+  · apply subtype.coe_injective.inj_on
 #align subgroup.rank_closure_finset_le_card Subgroup.rank_closure_finset_le_card
 #align add_subgroup.rank_closure_finset_le_card AddSubgroup.rank_closure_finset_le_card
 

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

@@ -354,7 +354,7 @@ theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ :
 
 @[to_additive]
 theorem Group.fg_iff' :
-    Group.FG G ↔ ∃ (n : _)(S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
+    Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
   Group.fg_def.trans ⟨fun ⟨S, hS⟩ => ⟨S.card, S, rfl, hS⟩, fun ⟨n, S, hn, hS⟩ => ⟨S, hS⟩⟩
 #align group.fg_iff' Group.fg_iff'
 #align add_group.fg_iff' AddGroup.fg_iff'

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

@@ -39,7 +39,7 @@ group.
 /-! ### Monoids and submonoids -/
 
 
-open Pointwise
+open scoped Pointwise
 
 variable {M N : Type _} [Monoid M] [AddMonoid N]
 

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

@@ -70,9 +70,6 @@ theorem Submonoid.fg_iff (P : Submonoid M) :
 #align add_submonoid.fg_iff AddSubmonoid.fg_iff
 -/
 
-/- warning: submonoid.fg_iff_add_fg -> Submonoid.fg_iff_add_fg is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fgₓ'. -/
 theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG :=
   ⟨fun h =>
     let ⟨S, hS, hf⟩ := (Submonoid.fg_iff _).1 h
@@ -84,9 +81,6 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG
       ⟨Multiplicative.ofAdd ⁻¹' T, by simp [← AddSubmonoid.toSubmonoid'_closure, hT], hf⟩⟩
 #align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fg
 
-/- warning: add_submonoid.fg_iff_mul_fg -> AddSubmonoid.fg_iff_mul_fg is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fgₓ'. -/
 theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG :=
   by
   convert(Submonoid.fg_iff_add_fg P.to_submonoid).symm
@@ -118,32 +112,14 @@ attribute [to_additive] Monoid.FG
 
 variable {M N}
 
-/- warning: monoid.fg_def -> Monoid.fg_def is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Submonoid.FG.{u1} M _inst_1 (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasTop.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Submonoid.FG.{u1} M _inst_1 (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instTopSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))
-Case conversion may be inaccurate. Consider using '#align monoid.fg_def Monoid.fg_defₓ'. -/
 theorem Monoid.fg_def : Monoid.FG M ↔ (⊤ : Submonoid M).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align monoid.fg_def Monoid.fg_def
 
-/- warning: add_monoid.fg_def -> AddMonoid.fg_def is a dubious translation:
-lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N], Iff (AddMonoid.FG.{u1} N _inst_2) (AddSubmonoid.FG.{u1} N _inst_2 (Top.top.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.hasTop.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))
-but is expected to have type
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N], Iff (AddMonoid.FG.{u1} N _inst_2) (AddSubmonoid.FG.{u1} N _inst_2 (Top.top.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instTopAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))
-Case conversion may be inaccurate. Consider using '#align add_monoid.fg_def AddMonoid.fg_defₓ'. -/
 theorem AddMonoid.fg_def : AddMonoid.FG N ↔ (⊤ : AddSubmonoid N).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_monoid.fg_def AddMonoid.fg_def
 
-/- warning: monoid.fg_iff -> Monoid.fg_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Exists.{succ u1} (Set.{u1} M) (fun (S : Set.{u1} M) => And (Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasTop.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Set.Finite.{u1} M S)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Exists.{succ u1} (Set.{u1} M) (fun (S : Set.{u1} M) => And (Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instTopSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Set.Finite.{u1} M S)))
-Case conversion may be inaccurate. Consider using '#align monoid.fg_iff Monoid.fg_iffₓ'. -/
 /-- An equivalent expression of `monoid.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_monoid.fg` in terms of `set.finite` instead of\n`finset`."]
@@ -201,12 +177,6 @@ theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG)
 #align add_submonoid.fg.map AddSubmonoid.FG.map
 -/
 
-/- warning: submonoid.fg.map_injective -> Submonoid.FG.map_injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e)) -> (Submonoid.FG.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.FG.{u1} M _inst_1 P)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.FG.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.FG.{u1} M _inst_1 P)
-Case conversion may be inaccurate. Consider using '#align submonoid.fg.map_injective Submonoid.FG.map_injectiveₓ'. -/
 @[to_additive]
 theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
     (he : Function.Injective e) (h : (P.map e).FG) : P.FG :=
@@ -221,12 +191,6 @@ theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (
 #align submonoid.fg.map_injective Submonoid.FG.map_injective
 #align add_submonoid.fg.map_injective AddSubmonoid.FG.map_injective
 
-/- warning: monoid.fg_iff_submonoid_fg -> Monoid.fg_iff_submonoid_fg is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (N : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) N) (Submonoid.toMonoid.{u1} M _inst_1 N)) (Submonoid.FG.{u1} M _inst_1 N)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (N : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x N)) (Submonoid.toMonoid.{u1} M _inst_1 N)) (Submonoid.FG.{u1} M _inst_1 N)
-Case conversion may be inaccurate. Consider using '#align monoid.fg_iff_submonoid_fg Monoid.fg_iff_submonoid_fgₓ'. -/
 @[simp, to_additive]
 theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
   by
@@ -235,12 +199,6 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
 #align monoid.fg_iff_submonoid_fg Monoid.fg_iff_submonoid_fg
 #align add_monoid.fg_iff_add_submonoid_fg AddMonoid.fg_iff_addSubmonoid_fg
 
-/- warning: monoid.fg_of_surjective -> Monoid.fg_of_surjective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) -> (Monoid.FG.{u2} M' _inst_3)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.FG.{u2} M' _inst_3)
-Case conversion may be inaccurate. Consider using '#align monoid.fg_of_surjective Monoid.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
     (hf : Function.Surjective f) : Monoid.FG M' := by
@@ -252,12 +210,6 @@ theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M 
 #align monoid.fg_of_surjective Monoid.fg_of_surjective
 #align add_monoid.fg_of_surjective AddMonoid.fg_of_surjective
 
-/- warning: monoid.fg_range -> Monoid.fg_range is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), Monoid.FG.{u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) M' (Submonoid.setLike.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3))) (MonoidHom.mrange.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) (Submonoid.toMonoid.{u2} M' _inst_3 (MonoidHom.mrange.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), Monoid.FG.{u2} (Subtype.{succ u2} M' (fun (x : M') => Membership.mem.{u2, u2} M' (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) M' (Submonoid.instSetLikeSubmonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3))) x (MonoidHom.mrange.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))) (Submonoid.toMonoid.{u2} M' _inst_3 (MonoidHom.mrange.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))
-Case conversion may be inaccurate. Consider using '#align monoid.fg_range Monoid.fg_rangeₓ'. -/
 @[to_additive]
 instance Monoid.fg_range {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M') :
     Monoid.FG f.mrange :=
@@ -273,24 +225,12 @@ theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG :=
 #align add_submonoid.multiples_fg AddSubmonoid.multiples_fg
 -/
 
-/- warning: monoid.powers_fg -> Monoid.powers_fg is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (r : M), Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.powers.{u1} M _inst_1 r)) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.powers.{u1} M _inst_1 r))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (r : M), Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.powers.{u1} M _inst_1 r))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.powers.{u1} M _inst_1 r))
-Case conversion may be inaccurate. Consider using '#align monoid.powers_fg Monoid.powers_fgₓ'. -/
 @[to_additive AddMonoid.multiples_fg]
 instance Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) :=
   (Monoid.fg_iff_submonoid_fg _).mpr (Submonoid.powers_fg r)
 #align monoid.powers_fg Monoid.powers_fg
 #align add_monoid.multiples_fg AddMonoid.multiples_fg
 
-/- warning: monoid.closure_finset_fg -> Monoid.closure_finset_fg is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Finset.{u1} M), Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} M) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (Finset.Set.hasCoeT.{u1} M))) s))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} M) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (Finset.Set.hasCoeT.{u1} M))) s)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Finset.{u1} M), Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Finset.toSet.{u1} M s)))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Finset.toSet.{u1} M s)))
-Case conversion may be inaccurate. Consider using '#align monoid.closure_finset_fg Monoid.closure_finset_fgₓ'. -/
 @[to_additive]
 instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure (s : Set M)) :=
   by
@@ -299,12 +239,6 @@ instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure
 #align monoid.closure_finset_fg Monoid.closure_finset_fg
 #align add_monoid.closure_finset_fg AddMonoid.closure_finset_fg
 
-/- warning: monoid.closure_finite_fg -> Monoid.closure_finite_fg is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M) [_inst_3 : Finite.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} M) Type.{u1} (Set.hasCoeToSort.{u1} M) s)], Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s)) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M) [_inst_3 : Finite.{succ u1} (Set.Elem.{u1} M s)], Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))
-Case conversion may be inaccurate. Consider using '#align monoid.closure_finite_fg Monoid.closure_finite_fgₓ'. -/
 @[to_additive]
 instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.closure s) :=
   haveI := Fintype.ofFinite s
@@ -365,24 +299,12 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.F
 #align add_subgroup.fg_iff_add_submonoid.fg AddSubgroup.fg_iff_addSubmonoid_fg
 -/
 
-/- warning: subgroup.fg_iff_add_fg -> Subgroup.fg_iff_add_fg is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))))) (fun (_x : RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) => (Subgroup.{u1} G _inst_3) -> (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (RelIso.hasCoeToFun.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
-Case conversion may be inaccurate. Consider using '#align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fgₓ'. -/
 theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG :=
   by
   rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.fg_iff_addSubmonoid_fg]
   exact (Subgroup.toSubmonoid P).fg_iff_add_fg
 #align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fg
 
-/- warning: add_subgroup.fg_iff_mul_fg -> AddSubgroup.fg_iff_mul_fg is a dubious translation:
-lean 3 declaration is
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4)))) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))))) (fun (_x : RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) => (AddSubgroup.{u1} H _inst_4) -> (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (RelIso.hasCoeToFun.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
-but is expected to have type
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
-Case conversion may be inaccurate. Consider using '#align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fgₓ'. -/
 theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG :=
   by
   rw [AddSubgroup.fg_iff_addSubmonoid_fg, Subgroup.fg_iff_submonoid_fg]
@@ -414,32 +336,14 @@ attribute [to_additive] Group.FG
 
 variable {G H}
 
-/- warning: group.fg_def -> Group.fg_def is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Subgroup.FG.{u1} G _inst_3 (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Subgroup.FG.{u1} G _inst_3 (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3)))
-Case conversion may be inaccurate. Consider using '#align group.fg_def Group.fg_defₓ'. -/
 theorem Group.fg_def : Group.FG G ↔ (⊤ : Subgroup G).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align group.fg_def Group.fg_def
 
-/- warning: add_group.fg_def -> AddGroup.fg_def is a dubious translation:
-lean 3 declaration is
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H], Iff (AddGroup.FG.{u1} H _inst_4) (AddSubgroup.FG.{u1} H _inst_4 (Top.top.{u1} (AddSubgroup.{u1} H _inst_4) (AddSubgroup.hasTop.{u1} H _inst_4)))
-but is expected to have type
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H], Iff (AddGroup.FG.{u1} H _inst_4) (AddSubgroup.FG.{u1} H _inst_4 (Top.top.{u1} (AddSubgroup.{u1} H _inst_4) (AddSubgroup.instTopAddSubgroup.{u1} H _inst_4)))
-Case conversion may be inaccurate. Consider using '#align add_group.fg_def AddGroup.fg_defₓ'. -/
 theorem AddGroup.fg_def : AddGroup.FG H ↔ (⊤ : AddSubgroup H).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_group.fg_def AddGroup.fg_def
 
-/- warning: group.fg_iff -> Group.fg_iff is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{succ u1} (Set.{u1} G) (fun (S : Set.{u1} G) => And (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 S) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))) (Set.Finite.{u1} G S)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{succ u1} (Set.{u1} G) (fun (S : Set.{u1} G) => And (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 S) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))) (Set.Finite.{u1} G S)))
-Case conversion may be inaccurate. Consider using '#align group.fg_iff Group.fg_iffₓ'. -/
 /-- An equivalent expression of `group.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_group.fg` in terms of `set.finite` instead of\n`finset`."]
@@ -448,12 +352,6 @@ theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ :
 #align group.fg_iff Group.fg_iff
 #align add_group.fg_iff AddGroup.fg_iff
 
-/- warning: group.fg_iff' -> Group.fg_iff' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{1} Nat (fun (n : Nat) => Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) n) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{1} Nat (fun (n : Nat) => Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) n) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))))))
-Case conversion may be inaccurate. Consider using '#align group.fg_iff' Group.fg_iff'ₓ'. -/
 @[to_additive]
 theorem Group.fg_iff' :
     Group.FG G ↔ ∃ (n : _)(S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
@@ -507,12 +405,6 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G :=
 #align add_group.fg_of_finite AddGroup.fg_of_finite
 -/
 
-/- warning: group.fg_of_surjective -> Group.fg_of_surjective is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (Group.FG.{u2} G' _inst_5)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.FG.{u2} G' _inst_5)
-Case conversion may be inaccurate. Consider using '#align group.fg_of_surjective Group.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G →* G'}
     (hf : Function.Surjective f) : Group.FG G' :=
@@ -521,24 +413,12 @@ theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G
 #align group.fg_of_surjective Group.fg_of_surjective
 #align add_group.fg_of_surjective AddGroup.fg_of_surjective
 
-/- warning: group.fg_range -> Group.fg_range is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), Group.FG.{u2} (coeSort.{succ u2, succ (succ u2)} (Subgroup.{u2} G' _inst_5) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.setLike.{u2} G' _inst_5)) (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), Group.FG.{u2} (Subtype.{succ u2} G' (fun (x : G') => Membership.mem.{u2, u2} G' (Subgroup.{u2} G' _inst_5) (SetLike.instMembership.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.instSetLikeSubgroup.{u2} G' _inst_5)) x (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))
-Case conversion may be inaccurate. Consider using '#align group.fg_range Group.fg_rangeₓ'. -/
 @[to_additive]
 instance Group.fg_range {G' : Type _} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range :=
   Group.fg_of_surjective f.rangeRestrict_surjective
 #align group.fg_range Group.fg_range
 #align add_group.fg_range AddGroup.fg_range
 
-/- warning: group.closure_finset_fg -> Group.closure_finset_fg is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s)))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s)))
-Case conversion may be inaccurate. Consider using '#align group.closure_finset_fg Group.closure_finset_fgₓ'. -/
 @[to_additive]
 instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s : Set G)) :=
   by
@@ -547,12 +427,6 @@ instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s
 #align group.closure_finset_fg Group.closure_finset_fg
 #align add_group.closure_finset_fg AddGroup.closure_finset_fg
 
-/- warning: group.closure_finite_fg -> Group.closure_finite_fg is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) s)], Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 s)) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (Set.Elem.{u1} G s)], Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s))
-Case conversion may be inaccurate. Consider using '#align group.closure_finite_fg Group.closure_finite_fgₓ'. -/
 @[to_additive]
 instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.FG (Subgroup.closure s) :=
   haveI := Fintype.ofFinite s
@@ -571,12 +445,6 @@ noncomputable def Group.rank [h : Group.FG G] :=
 #align add_group.rank AddGroup.rank
 -/
 
-/- warning: group.rank_spec -> Group.rank_spec is a dubious translation:
-lean 3 declaration is
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3], Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) (Group.rank.{u1} G _inst_3 h)) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))))
-but is expected to have type
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3], Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) (Group.rank.{u1} G _inst_3 h)) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))))
-Case conversion may be inaccurate. Consider using '#align group.rank_spec Group.rank_specₓ'. -/
 @[to_additive]
 theorem Group.rank_spec [h : Group.FG G] :
     ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ :=
@@ -584,12 +452,6 @@ theorem Group.rank_spec [h : Group.FG G] :
 #align group.rank_spec Group.rank_spec
 #align add_group.rank_spec AddGroup.rank_spec
 
-/- warning: group.rank_le -> Group.rank_le is a dubious translation:
-lean 3 declaration is
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3] {S : Finset.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u1} G _inst_3 h) (Finset.card.{u1} G S))
-but is expected to have type
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3] {S : Finset.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G _inst_3 h) (Finset.card.{u1} G S))
-Case conversion may be inaccurate. Consider using '#align group.rank_le Group.rank_leₓ'. -/
 @[to_additive]
 theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
     Group.rank G ≤ S.card :=
@@ -599,12 +461,6 @@ theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S
 
 variable {G} {G' : Type _} [Group G']
 
-/- warning: group.rank_le_of_surjective -> Group.rank_le_of_surjective is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] [_inst_7 : Group.FG.{u2} G' _inst_5] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} G' _inst_5 _inst_7) (Group.rank.{u1} G _inst_3 _inst_6))
-but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] [_inst_7 : Group.FG.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
-Case conversion may be inaccurate. Consider using '#align group.rank_le_of_surjective Group.rank_le_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
     (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by
@@ -617,24 +473,12 @@ theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
 #align group.rank_le_of_surjective Group.rank_le_of_surjective
 #align add_group.rank_le_of_surjective AddGroup.rank_le_of_surjective
 
-/- warning: group.rank_range_le -> Group.rank_range_le is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} (coeSort.{succ u2, succ (succ u2)} (Subgroup.{u2} G' _inst_5) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.setLike.{u2} G' _inst_5)) (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Group.fg_range.{u1, u2} G _inst_3 G' _inst_5 _inst_6 f)) (Group.rank.{u1} G _inst_3 _inst_6)
-but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] {f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))}, LE.le.{0} Nat instLENat (Group.rank.{u1} (Subtype.{succ u1} G' (fun (x : G') => Membership.mem.{u1, u1} G' (Subgroup.{u1} G' _inst_5) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G' _inst_5) G' (Subgroup.instSetLikeSubgroup.{u1} G' _inst_5)) x (MonoidHom.range.{u2, u1} G _inst_3 G' _inst_5 f))) (Subgroup.toGroup.{u1} G' _inst_5 (MonoidHom.range.{u2, u1} G _inst_3 G' _inst_5 f)) (Group.fg_range.{u2, u1} G _inst_3 G' _inst_5 _inst_6 f)) (Group.rank.{u2} G _inst_3 _inst_6)
-Case conversion may be inaccurate. Consider using '#align group.rank_range_le Group.rank_range_leₓ'. -/
 @[to_additive]
 theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G :=
   Group.rank_le_of_surjective f.range_restrict f.rangeRestrict_surjective
 #align group.rank_range_le Group.rank_range_le
 #align add_group.rank_range_le AddGroup.rank_range_le
 
-/- warning: group.rank_congr -> Group.rank_congr is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] [_inst_7 : Group.FG.{u2} G' _inst_5], (MulEquiv.{u1, u2} G G' (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toHasMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))))) -> (Eq.{1} Nat (Group.rank.{u1} G _inst_3 _inst_6) (Group.rank.{u2} G' _inst_5 _inst_7))
-but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] [_inst_7 : Group.FG.{u1} G' _inst_5], (MulEquiv.{u2, u1} G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))))) -> (Eq.{1} Nat (Group.rank.{u2} G _inst_3 _inst_6) (Group.rank.{u1} G' _inst_5 _inst_7))
-Case conversion may be inaccurate. Consider using '#align group.rank_congr Group.rank_congrₓ'. -/
 @[to_additive]
 theorem Group.rank_congr [Group.FG G] [Group.FG G'] (f : G ≃* G') : Group.rank G = Group.rank G' :=
   le_antisymm (Group.rank_le_of_surjective f.symm f.symm.Surjective)
@@ -646,24 +490,12 @@ end Group
 
 namespace Subgroup
 
-/- warning: subgroup.rank_congr -> Subgroup.rank_congr is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {H : Subgroup.{u1} G _inst_3} {K : Subgroup.{u1} G _inst_3} [_inst_5 : Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) H) (Subgroup.toGroup.{u1} G _inst_3 H)] [_inst_6 : Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) K) (Subgroup.toGroup.{u1} G _inst_3 K)], (Eq.{succ u1} (Subgroup.{u1} G _inst_3) H K) -> (Eq.{1} Nat (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) H) (Subgroup.toGroup.{u1} G _inst_3 H) _inst_5) (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) K) (Subgroup.toGroup.{u1} G _inst_3 K) _inst_6))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {H : Subgroup.{u1} G _inst_3} {K : Subgroup.{u1} G _inst_3} [_inst_5 : Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x H)) (Subgroup.toGroup.{u1} G _inst_3 H)] [_inst_6 : Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x K)) (Subgroup.toGroup.{u1} G _inst_3 K)], (Eq.{succ u1} (Subgroup.{u1} G _inst_3) H K) -> (Eq.{1} Nat (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x H)) (Subgroup.toGroup.{u1} G _inst_3 H) _inst_5) (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x K)) (Subgroup.toGroup.{u1} G _inst_3 K) _inst_6))
-Case conversion may be inaccurate. Consider using '#align subgroup.rank_congr Subgroup.rank_congrₓ'. -/
 @[to_additive]
 theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
     Group.rank H = Group.rank K := by subst h
 #align subgroup.rank_congr Subgroup.rank_congr
 #align add_subgroup.rank_congr AddSubgroup.rank_congr
 
-/- warning: subgroup.rank_closure_finset_le_card -> Subgroup.rank_closure_finset_le_card is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), LE.le.{0} Nat Nat.hasLe (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s))) (Group.closure_finite_fg.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s) (Finite.of_fintype.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s)) (FinsetCoe.fintype.{u1} G s)))) (Finset.card.{u1} G s)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), LE.le.{0} Nat instLENat (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s)))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s))) (Group.closure_finite_fg.{u1} G _inst_3 (Finset.toSet.{u1} G s) (Finite.of_fintype.{u1} (Set.Elem.{u1} G (Finset.toSet.{u1} G s)) (FinsetCoe.fintype.{u1} G s)))) (Finset.card.{u1} G s)
-Case conversion may be inaccurate. Consider using '#align subgroup.rank_closure_finset_le_card Subgroup.rank_closure_finset_le_cardₓ'. -/
 @[to_additive]
 theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card := by
   classical
@@ -679,12 +511,6 @@ theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Se
 #align subgroup.rank_closure_finset_le_card Subgroup.rank_closure_finset_le_card
 #align add_subgroup.rank_closure_finset_le_card AddSubgroup.rank_closure_finset_le_card
 
-/- warning: subgroup.rank_closure_finite_le_nat_card -> Subgroup.rank_closure_finite_le_nat_card is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) s)], LE.le.{0} Nat Nat.hasLe (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 s)) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s)) (Group.closure_finite_fg.{u1} G _inst_3 s _inst_5)) (Nat.card.{u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (Set.Elem.{u1} G s)], LE.le.{0} Nat instLENat (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s)) (Group.closure_finite_fg.{u1} G _inst_3 s _inst_5)) (Nat.card.{u1} (Set.Elem.{u1} G s))
-Case conversion may be inaccurate. Consider using '#align subgroup.rank_closure_finite_le_nat_card Subgroup.rank_closure_finite_le_nat_cardₓ'. -/
 @[to_additive]
 theorem rank_closure_finite_le_nat_card (s : Set G) [Finite s] :
     Group.rank (closure s) ≤ Nat.card s :=

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

@@ -71,10 +71,7 @@ theorem Submonoid.fg_iff (P : Submonoid M) :
 -/
 
 /- warning: submonoid.fg_iff_add_fg -> Submonoid.fg_iff_add_fg is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (fun (_x : RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) => (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) -> (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (RelIso.hasCoeToFun.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
+<too large>
 Case conversion may be inaccurate. Consider using '#align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fgₓ'. -/
 theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG :=
   ⟨fun h =>
@@ -88,10 +85,7 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG
 #align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fg
 
 /- warning: add_submonoid.fg_iff_mul_fg -> AddSubmonoid.fg_iff_mul_fg is a dubious translation:
-lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) (fun (_x : RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) => (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) -> (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (RelIso.hasCoeToFun.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
-but is expected to have type
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
+<too large>
 Case conversion may be inaccurate. Consider using '#align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fgₓ'. -/
 theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG :=
   by

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

@@ -74,7 +74,7 @@ theorem Submonoid.fg_iff (P : Submonoid M) :
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (fun (_x : RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) => (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) -> (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (RelIso.hasCoeToFun.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 Case conversion may be inaccurate. Consider using '#align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fgₓ'. -/
 theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG :=
   ⟨fun h =>
@@ -91,7 +91,7 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG
 lean 3 declaration is
   forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) (fun (_x : RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) => (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) -> (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (RelIso.hasCoeToFun.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 but is expected to have type
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
+  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fgₓ'. -/
 theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG :=
   by
@@ -211,7 +211,7 @@ theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG)
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e)) -> (Submonoid.FG.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.FG.{u1} M _inst_1 P)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.FG.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.FG.{u1} M _inst_1 P)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.FG.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.FG.{u1} M _inst_1 P)
 Case conversion may be inaccurate. Consider using '#align submonoid.fg.map_injective Submonoid.FG.map_injectiveₓ'. -/
 @[to_additive]
 theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
@@ -245,7 +245,7 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) -> (Monoid.FG.{u2} M' _inst_3)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.FG.{u2} M' _inst_3)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.FG.{u2} M' _inst_3)
 Case conversion may be inaccurate. Consider using '#align monoid.fg_of_surjective Monoid.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
@@ -375,7 +375,7 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.F
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))))) (fun (_x : RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) => (Subgroup.{u1} G _inst_3) -> (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (RelIso.hasCoeToFun.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 Case conversion may be inaccurate. Consider using '#align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fgₓ'. -/
 theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG :=
   by
@@ -387,7 +387,7 @@ theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG :=
 lean 3 declaration is
   forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4)))) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))))) (fun (_x : RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) => (AddSubgroup.{u1} H _inst_4) -> (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (RelIso.hasCoeToFun.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 but is expected to have type
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
+  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302)) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1285 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1287 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1285 x._@.Mathlib.Order.Hom.Basic._hyg.1287) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1300 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1302 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1300 x._@.Mathlib.Order.Hom.Basic._hyg.1302))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 Case conversion may be inaccurate. Consider using '#align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fgₓ'. -/
 theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG :=
   by
@@ -517,7 +517,7 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G :=
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (Group.FG.{u2} G' _inst_5)
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.FG.{u2} G' _inst_5)
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.FG.{u2} G' _inst_5)
 Case conversion may be inaccurate. Consider using '#align group.fg_of_surjective Group.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G →* G'}
@@ -609,7 +609,7 @@ variable {G} {G' : Type _} [Group G']
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] [_inst_7 : Group.FG.{u2} G' _inst_5] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} G' _inst_5 _inst_7) (Group.rank.{u1} G _inst_3 _inst_6))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] [_inst_7 : Group.FG.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
+  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] [_inst_7 : Group.FG.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
 Case conversion may be inaccurate. Consider using '#align group.rank_le_of_surjective Group.rank_le_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')

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

@@ -72,7 +72,7 @@ theorem Submonoid.fg_iff (P : Submonoid M) :
 
 /- warning: submonoid.fg_iff_add_fg -> Submonoid.fg_iff_add_fg is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (fun (_x : RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) => (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) -> (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (RelIso.hasCoeToFun.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (fun (_x : RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) => (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) -> (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (RelIso.hasCoeToFun.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toHasLe.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 Case conversion may be inaccurate. Consider using '#align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fgₓ'. -/
@@ -89,7 +89,7 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG
 
 /- warning: add_submonoid.fg_iff_mul_fg -> AddSubmonoid.fg_iff_mul_fg is a dubious translation:
 lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) (fun (_x : RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) => (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) -> (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (RelIso.hasCoeToFun.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
+  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) (fun (_x : RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) => (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) -> (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (RelIso.hasCoeToFun.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toHasLe.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 but is expected to have type
   forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fgₓ'. -/
@@ -373,7 +373,7 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.F
 
 /- warning: subgroup.fg_iff_add_fg -> Subgroup.fg_iff_add_fg is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)))) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))))) (fun (_x : RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) => (Subgroup.{u1} G _inst_3) -> (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (RelIso.hasCoeToFun.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))))) (fun (_x : RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) => (Subgroup.{u1} G _inst_3) -> (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (RelIso.hasCoeToFun.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toHasLe.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 Case conversion may be inaccurate. Consider using '#align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fgₓ'. -/
@@ -385,7 +385,7 @@ theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG :=
 
 /- warning: add_subgroup.fg_iff_mul_fg -> AddSubgroup.fg_iff_mul_fg is a dubious translation:
 lean 3 declaration is
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4)))) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))))) (fun (_x : RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) => (AddSubgroup.{u1} H _inst_4) -> (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (RelIso.hasCoeToFun.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
+  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4)))) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))))) (fun (_x : RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) => (AddSubgroup.{u1} H _inst_4) -> (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (RelIso.hasCoeToFun.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toHasLe.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toHasLe.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 but is expected to have type
   forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 Case conversion may be inaccurate. Consider using '#align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fgₓ'. -/

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

@@ -45,25 +45,25 @@ variable {M N : Type _} [Monoid M] [AddMonoid N]
 
 section Submonoid
 
-#print Submonoid.Fg /-
+#print Submonoid.FG /-
 /-- A submonoid of `M` is finitely generated if it is the closure of a finite subset of `M`. -/
 @[to_additive]
-def Submonoid.Fg (P : Submonoid M) : Prop :=
+def Submonoid.FG (P : Submonoid M) : Prop :=
   ∃ S : Finset M, Submonoid.closure ↑S = P
-#align submonoid.fg Submonoid.Fg
-#align add_submonoid.fg AddSubmonoid.Fg
+#align submonoid.fg Submonoid.FG
+#align add_submonoid.fg AddSubmonoid.FG
 -/
 
 /-- An additive submonoid of `N` is finitely generated if it is the closure of a finite subset of
 `M`. -/
-add_decl_doc AddSubmonoid.Fg
+add_decl_doc AddSubmonoid.FG
 
 #print Submonoid.fg_iff /-
 /-- An equivalent expression of `submonoid.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_submonoid.fg` in terms of `set.finite` instead of\n`finset`."]
 theorem Submonoid.fg_iff (P : Submonoid M) :
-    Submonoid.Fg P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite :=
+    Submonoid.FG P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite :=
   ⟨fun ⟨S, hS⟩ => ⟨S, hS, Finset.finite_toSet S⟩, fun ⟨S, hS, hf⟩ =>
     ⟨Set.Finite.toFinset hf, by simp [hS]⟩⟩
 #align submonoid.fg_iff Submonoid.fg_iff
@@ -72,11 +72,11 @@ theorem Submonoid.fg_iff (P : Submonoid M) :
 
 /- warning: submonoid.fg_iff_add_fg -> Submonoid.fg_iff_add_fg is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.Fg.{u1} M _inst_1 P) (AddSubmonoid.Fg.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (fun (_x : RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) => (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) -> (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (RelIso.hasCoeToFun.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (fun (_x : RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) => (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) -> (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (RelIso.hasCoeToFun.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.Fg.{u1} M _inst_1 P) (AddSubmonoid.Fg.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.FG.{u1} M _inst_1 P) (AddSubmonoid.FG.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 Case conversion may be inaccurate. Consider using '#align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fgₓ'. -/
-theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.Fg ↔ P.toAddSubmonoid.Fg :=
+theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG :=
   ⟨fun h =>
     let ⟨S, hS, hf⟩ := (Submonoid.fg_iff _).1 h
     (AddSubmonoid.fg_iff _).mpr
@@ -89,11 +89,11 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.Fg ↔ P.toAddSubmonoid.Fg
 
 /- warning: add_submonoid.fg_iff_mul_fg -> AddSubmonoid.fg_iff_mul_fg is a dubious translation:
 lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.Fg.{u1} N _inst_2 P) (Submonoid.Fg.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) (fun (_x : RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) => (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) -> (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (RelIso.hasCoeToFun.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
+  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) (fun (_x : RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) => (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) -> (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (RelIso.hasCoeToFun.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 but is expected to have type
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.Fg.{u1} N _inst_2 P) (Submonoid.Fg.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
+  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.FG.{u1} N _inst_2 P) (Submonoid.FG.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fgₓ'. -/
-theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.Fg ↔ P.toSubmonoid.Fg :=
+theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG :=
   by
   convert(Submonoid.fg_iff_add_fg P.to_submonoid).symm
   exact SetLike.ext' rfl
@@ -105,88 +105,88 @@ section Monoid
 
 variable (M N)
 
-#print Monoid.Fg /-
+#print Monoid.FG /-
 /-- A monoid is finitely generated if it is finitely generated as a submonoid of itself. -/
-class Monoid.Fg : Prop where
-  out : (⊤ : Submonoid M).Fg
-#align monoid.fg Monoid.Fg
+class Monoid.FG : Prop where
+  out : (⊤ : Submonoid M).FG
+#align monoid.fg Monoid.FG
 -/
 
-#print AddMonoid.Fg /-
+#print AddMonoid.FG /-
 /-- An additive monoid is finitely generated if it is finitely generated as an additive submonoid of
 itself. -/
-class AddMonoid.Fg : Prop where
-  out : (⊤ : AddSubmonoid N).Fg
-#align add_monoid.fg AddMonoid.Fg
+class AddMonoid.FG : Prop where
+  out : (⊤ : AddSubmonoid N).FG
+#align add_monoid.fg AddMonoid.FG
 -/
 
-attribute [to_additive] Monoid.Fg
+attribute [to_additive] Monoid.FG
 
 variable {M N}
 
 /- warning: monoid.fg_def -> Monoid.fg_def is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.Fg.{u1} M _inst_1) (Submonoid.Fg.{u1} M _inst_1 (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasTop.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Submonoid.FG.{u1} M _inst_1 (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasTop.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.Fg.{u1} M _inst_1) (Submonoid.Fg.{u1} M _inst_1 (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instTopSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Submonoid.FG.{u1} M _inst_1 (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instTopSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))
 Case conversion may be inaccurate. Consider using '#align monoid.fg_def Monoid.fg_defₓ'. -/
-theorem Monoid.fg_def : Monoid.Fg M ↔ (⊤ : Submonoid M).Fg :=
+theorem Monoid.fg_def : Monoid.FG M ↔ (⊤ : Submonoid M).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align monoid.fg_def Monoid.fg_def
 
 /- warning: add_monoid.fg_def -> AddMonoid.fg_def is a dubious translation:
 lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N], Iff (AddMonoid.Fg.{u1} N _inst_2) (AddSubmonoid.Fg.{u1} N _inst_2 (Top.top.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.hasTop.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))
+  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N], Iff (AddMonoid.FG.{u1} N _inst_2) (AddSubmonoid.FG.{u1} N _inst_2 (Top.top.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.hasTop.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))
 but is expected to have type
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N], Iff (AddMonoid.Fg.{u1} N _inst_2) (AddSubmonoid.Fg.{u1} N _inst_2 (Top.top.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instTopAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))
+  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N], Iff (AddMonoid.FG.{u1} N _inst_2) (AddSubmonoid.FG.{u1} N _inst_2 (Top.top.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instTopAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))
 Case conversion may be inaccurate. Consider using '#align add_monoid.fg_def AddMonoid.fg_defₓ'. -/
-theorem AddMonoid.fg_def : AddMonoid.Fg N ↔ (⊤ : AddSubmonoid N).Fg :=
+theorem AddMonoid.fg_def : AddMonoid.FG N ↔ (⊤ : AddSubmonoid N).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_monoid.fg_def AddMonoid.fg_def
 
 /- warning: monoid.fg_iff -> Monoid.fg_iff is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.Fg.{u1} M _inst_1) (Exists.{succ u1} (Set.{u1} M) (fun (S : Set.{u1} M) => And (Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasTop.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Set.Finite.{u1} M S)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Exists.{succ u1} (Set.{u1} M) (fun (S : Set.{u1} M) => And (Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasTop.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Set.Finite.{u1} M S)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.Fg.{u1} M _inst_1) (Exists.{succ u1} (Set.{u1} M) (fun (S : Set.{u1} M) => And (Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instTopSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Set.Finite.{u1} M S)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Iff (Monoid.FG.{u1} M _inst_1) (Exists.{succ u1} (Set.{u1} M) (fun (S : Set.{u1} M) => And (Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Top.top.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instTopSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Set.Finite.{u1} M S)))
 Case conversion may be inaccurate. Consider using '#align monoid.fg_iff Monoid.fg_iffₓ'. -/
 /-- An equivalent expression of `monoid.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_monoid.fg` in terms of `set.finite` instead of\n`finset`."]
 theorem Monoid.fg_iff :
-    Monoid.Fg M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite :=
+    Monoid.FG M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite :=
   ⟨fun h => (Submonoid.fg_iff ⊤).1 h.out, fun h => ⟨(Submonoid.fg_iff ⊤).2 h⟩⟩
 #align monoid.fg_iff Monoid.fg_iff
 #align add_monoid.fg_iff AddMonoid.fg_iff
 
 #print Monoid.fg_iff_add_fg /-
-theorem Monoid.fg_iff_add_fg : Monoid.Fg M ↔ AddMonoid.Fg (Additive M) :=
+theorem Monoid.fg_iff_add_fg : Monoid.FG M ↔ AddMonoid.FG (Additive M) :=
   ⟨fun h => ⟨(Submonoid.fg_iff_add_fg ⊤).1 h.out⟩, fun h => ⟨(Submonoid.fg_iff_add_fg ⊤).2 h.out⟩⟩
 #align monoid.fg_iff_add_fg Monoid.fg_iff_add_fg
 -/
 
 #print AddMonoid.fg_iff_mul_fg /-
-theorem AddMonoid.fg_iff_mul_fg : AddMonoid.Fg N ↔ Monoid.Fg (Multiplicative N) :=
+theorem AddMonoid.fg_iff_mul_fg : AddMonoid.FG N ↔ Monoid.FG (Multiplicative N) :=
   ⟨fun h => ⟨(AddSubmonoid.fg_iff_mul_fg ⊤).1 h.out⟩, fun h =>
     ⟨(AddSubmonoid.fg_iff_mul_fg ⊤).2 h.out⟩⟩
 #align add_monoid.fg_iff_mul_fg AddMonoid.fg_iff_mul_fg
 -/
 
 #print AddMonoid.fg_of_monoid_fg /-
-instance AddMonoid.fg_of_monoid_fg [Monoid.Fg M] : AddMonoid.Fg (Additive M) :=
+instance AddMonoid.fg_of_monoid_fg [Monoid.FG M] : AddMonoid.FG (Additive M) :=
   Monoid.fg_iff_add_fg.1 ‹_›
 #align add_monoid.fg_of_monoid_fg AddMonoid.fg_of_monoid_fg
 -/
 
 #print Monoid.fg_of_addMonoid_fg /-
-instance Monoid.fg_of_addMonoid_fg [AddMonoid.Fg N] : Monoid.Fg (Multiplicative N) :=
+instance Monoid.fg_of_addMonoid_fg [AddMonoid.FG N] : Monoid.FG (Multiplicative N) :=
   AddMonoid.fg_iff_mul_fg.1 ‹_›
 #align monoid.fg_of_add_monoid_fg Monoid.fg_of_addMonoid_fg
 -/
 
 #print Monoid.fg_of_finite /-
 @[to_additive]
-instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.Fg M :=
+instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.FG M :=
   by
   cases nonempty_fintype M
   exact ⟨⟨Finset.univ, by rw [Finset.coe_univ] <;> exact Submonoid.closure_univ⟩⟩
@@ -196,26 +196,26 @@ instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.Fg M :=
 
 end Monoid
 
-#print Submonoid.Fg.map /-
+#print Submonoid.FG.map /-
 @[to_additive]
-theorem Submonoid.Fg.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.Fg) (e : M →* M') :
-    (P.map e).Fg := by
+theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
+    (P.map e).FG := by
   classical
     obtain ⟨s, rfl⟩ := h
     exact ⟨s.image e, by rw [Finset.coe_image, MonoidHom.map_mclosure]⟩
-#align submonoid.fg.map Submonoid.Fg.map
-#align add_submonoid.fg.map AddSubmonoid.Fg.map
+#align submonoid.fg.map Submonoid.FG.map
+#align add_submonoid.fg.map AddSubmonoid.FG.map
 -/
 
-/- warning: submonoid.fg.map_injective -> Submonoid.Fg.map_injective is a dubious translation:
+/- warning: submonoid.fg.map_injective -> Submonoid.FG.map_injective is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e)) -> (Submonoid.FG.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.FG.{u1} M _inst_1 P)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
-Case conversion may be inaccurate. Consider using '#align submonoid.fg.map_injective Submonoid.Fg.map_injectiveₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.FG.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.FG.{u1} M _inst_1 P)
+Case conversion may be inaccurate. Consider using '#align submonoid.fg.map_injective Submonoid.FG.map_injectiveₓ'. -/
 @[to_additive]
-theorem Submonoid.Fg.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
-    (he : Function.Injective e) (h : (P.map e).Fg) : P.Fg :=
+theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
+    (he : Function.Injective e) (h : (P.map e).FG) : P.FG :=
   by
   obtain ⟨s, hs⟩ := h
   use s.preimage e (he.inj_on _)
@@ -224,17 +224,17 @@ theorem Submonoid.Fg.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (
   congr
   rw [Set.image_preimage_eq_iff, ← e.coe_mrange, ← Submonoid.closure_le, hs, e.mrange_eq_map]
   exact Submonoid.monotone_map le_top
-#align submonoid.fg.map_injective Submonoid.Fg.map_injective
-#align add_submonoid.fg.map_injective AddSubmonoid.Fg.map_injective
+#align submonoid.fg.map_injective Submonoid.FG.map_injective
+#align add_submonoid.fg.map_injective AddSubmonoid.FG.map_injective
 
 /- warning: monoid.fg_iff_submonoid_fg -> Monoid.fg_iff_submonoid_fg is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (N : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Monoid.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) N) (Submonoid.toMonoid.{u1} M _inst_1 N)) (Submonoid.Fg.{u1} M _inst_1 N)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (N : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) N) (Submonoid.toMonoid.{u1} M _inst_1 N)) (Submonoid.FG.{u1} M _inst_1 N)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (N : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Monoid.Fg.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x N)) (Submonoid.toMonoid.{u1} M _inst_1 N)) (Submonoid.Fg.{u1} M _inst_1 N)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (N : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x N)) (Submonoid.toMonoid.{u1} M _inst_1 N)) (Submonoid.FG.{u1} M _inst_1 N)
 Case conversion may be inaccurate. Consider using '#align monoid.fg_iff_submonoid_fg Monoid.fg_iff_submonoid_fgₓ'. -/
 @[simp, to_additive]
-theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.Fg N ↔ N.Fg :=
+theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG :=
   by
   conv_rhs => rw [← N.range_subtype, MonoidHom.mrange_eq_map]
   exact ⟨fun h => h.out.map N.subtype, fun h => ⟨h.map_injective N.subtype Subtype.coe_injective⟩⟩
@@ -243,13 +243,13 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.Fg N ↔ N.Fg :=
 
 /- warning: monoid.fg_of_surjective -> Monoid.fg_of_surjective is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) -> (Monoid.Fg.{u2} M' _inst_3)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) -> (Monoid.FG.{u2} M' _inst_3)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.Fg.{u2} M' _inst_3)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.FG.{u2} M' _inst_3)
 Case conversion may be inaccurate. Consider using '#align monoid.fg_of_surjective Monoid.fg_of_surjectiveₓ'. -/
 @[to_additive]
-theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M →* M')
-    (hf : Function.Surjective f) : Monoid.Fg M' := by
+theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
+    (hf : Function.Surjective f) : Monoid.FG M' := by
   classical
     obtain ⟨s, hs⟩ := monoid.fg_def.mp ‹_›
     use s.image f
@@ -260,20 +260,20 @@ theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M 
 
 /- warning: monoid.fg_range -> Monoid.fg_range is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), Monoid.Fg.{u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) M' (Submonoid.setLike.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3))) (MonoidHom.mrange.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) (Submonoid.toMonoid.{u2} M' _inst_3 (MonoidHom.mrange.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), Monoid.FG.{u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) M' (Submonoid.setLike.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3))) (MonoidHom.mrange.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) (Submonoid.toMonoid.{u2} M' _inst_3 (MonoidHom.mrange.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), Monoid.Fg.{u2} (Subtype.{succ u2} M' (fun (x : M') => Membership.mem.{u2, u2} M' (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) M' (Submonoid.instSetLikeSubmonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3))) x (MonoidHom.mrange.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))) (Submonoid.toMonoid.{u2} M' _inst_3 (MonoidHom.mrange.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.FG.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), Monoid.FG.{u2} (Subtype.{succ u2} M' (fun (x : M') => Membership.mem.{u2, u2} M' (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) M' (Submonoid.instSetLikeSubmonoid.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3))) x (MonoidHom.mrange.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))) (Submonoid.toMonoid.{u2} M' _inst_3 (MonoidHom.mrange.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f))
 Case conversion may be inaccurate. Consider using '#align monoid.fg_range Monoid.fg_rangeₓ'. -/
 @[to_additive]
-instance Monoid.fg_range {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M →* M') :
-    Monoid.Fg f.mrange :=
+instance Monoid.fg_range {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M') :
+    Monoid.FG f.mrange :=
   Monoid.fg_of_surjective f.mrangeRestrict f.mrangeRestrict_surjective
 #align monoid.fg_range Monoid.fg_range
 #align add_monoid.fg_range AddMonoid.fg_range
 
 #print Submonoid.powers_fg /-
 @[to_additive AddSubmonoid.multiples_fg]
-theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).Fg :=
+theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG :=
   ⟨{r}, (Finset.coe_singleton r).symm ▸ (Submonoid.powers_eq_closure r).symm⟩
 #align submonoid.powers_fg Submonoid.powers_fg
 #align add_submonoid.multiples_fg AddSubmonoid.multiples_fg
@@ -281,24 +281,24 @@ theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).Fg :=
 
 /- warning: monoid.powers_fg -> Monoid.powers_fg is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (r : M), Monoid.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.powers.{u1} M _inst_1 r)) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.powers.{u1} M _inst_1 r))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (r : M), Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.powers.{u1} M _inst_1 r)) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.powers.{u1} M _inst_1 r))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (r : M), Monoid.Fg.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.powers.{u1} M _inst_1 r))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.powers.{u1} M _inst_1 r))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (r : M), Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.powers.{u1} M _inst_1 r))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.powers.{u1} M _inst_1 r))
 Case conversion may be inaccurate. Consider using '#align monoid.powers_fg Monoid.powers_fgₓ'. -/
 @[to_additive AddMonoid.multiples_fg]
-instance Monoid.powers_fg (r : M) : Monoid.Fg (Submonoid.powers r) :=
+instance Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) :=
   (Monoid.fg_iff_submonoid_fg _).mpr (Submonoid.powers_fg r)
 #align monoid.powers_fg Monoid.powers_fg
 #align add_monoid.multiples_fg AddMonoid.multiples_fg
 
 /- warning: monoid.closure_finset_fg -> Monoid.closure_finset_fg is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Finset.{u1} M), Monoid.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} M) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (Finset.Set.hasCoeT.{u1} M))) s))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} M) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (Finset.Set.hasCoeT.{u1} M))) s)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Finset.{u1} M), Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} M) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (Finset.Set.hasCoeT.{u1} M))) s))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} M) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} M) (Set.{u1} M) (Finset.Set.hasCoeT.{u1} M))) s)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Finset.{u1} M), Monoid.Fg.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Finset.toSet.{u1} M s)))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Finset.toSet.{u1} M s)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Finset.{u1} M), Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Finset.toSet.{u1} M s)))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Finset.toSet.{u1} M s)))
 Case conversion may be inaccurate. Consider using '#align monoid.closure_finset_fg Monoid.closure_finset_fgₓ'. -/
 @[to_additive]
-instance Monoid.closure_finset_fg (s : Finset M) : Monoid.Fg (Submonoid.closure (s : Set M)) :=
+instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure (s : Set M)) :=
   by
   refine' ⟨⟨s.preimage coe (subtype.coe_injective.inj_on _), _⟩⟩
   rw [Finset.coe_preimage, Submonoid.closure_closure_coe_preimage]
@@ -307,12 +307,12 @@ instance Monoid.closure_finset_fg (s : Finset M) : Monoid.Fg (Submonoid.closure
 
 /- warning: monoid.closure_finite_fg -> Monoid.closure_finite_fg is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M) [_inst_3 : Finite.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} M) Type.{u1} (Set.hasCoeToSort.{u1} M) s)], Monoid.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s)) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M) [_inst_3 : Finite.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} M) Type.{u1} (Set.hasCoeToSort.{u1} M) s)], Monoid.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s)) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M) [_inst_3 : Finite.{succ u1} (Set.Elem.{u1} M s)], Monoid.Fg.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M) [_inst_3 : Finite.{succ u1} (Set.Elem.{u1} M s)], Monoid.FG.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))) (Submonoid.toMonoid.{u1} M _inst_1 (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s))
 Case conversion may be inaccurate. Consider using '#align monoid.closure_finite_fg Monoid.closure_finite_fgₓ'. -/
 @[to_additive]
-instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.Fg (Submonoid.closure s) :=
+instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.closure s) :=
   haveI := Fintype.ofFinite s
   s.coe_to_finset ▸ Monoid.closure_finset_fg s.to_finset
 #align monoid.closure_finite_fg Monoid.closure_finite_fg
@@ -325,25 +325,25 @@ variable {G H : Type _} [Group G] [AddGroup H]
 
 section Subgroup
 
-#print Subgroup.Fg /-
+#print Subgroup.FG /-
 /-- A subgroup of `G` is finitely generated if it is the closure of a finite subset of `G`. -/
 @[to_additive]
-def Subgroup.Fg (P : Subgroup G) : Prop :=
+def Subgroup.FG (P : Subgroup G) : Prop :=
   ∃ S : Finset G, Subgroup.closure ↑S = P
-#align subgroup.fg Subgroup.Fg
-#align add_subgroup.fg AddSubgroup.Fg
+#align subgroup.fg Subgroup.FG
+#align add_subgroup.fg AddSubgroup.FG
 -/
 
 /-- An additive subgroup of `H` is finitely generated if it is the closure of a finite subset of
 `H`. -/
-add_decl_doc AddSubgroup.Fg
+add_decl_doc AddSubgroup.FG
 
 #print Subgroup.fg_iff /-
 /-- An equivalent expression of `subgroup.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_subgroup.fg` in terms of `set.finite` instead of\n`finset`."]
 theorem Subgroup.fg_iff (P : Subgroup G) :
-    Subgroup.Fg P ↔ ∃ S : Set G, Subgroup.closure S = P ∧ S.Finite :=
+    Subgroup.FG P ↔ ∃ S : Set G, Subgroup.closure S = P ∧ S.Finite :=
   ⟨fun ⟨S, hS⟩ => ⟨S, hS, Finset.finite_toSet S⟩, fun ⟨S, hS, hf⟩ =>
     ⟨Set.Finite.toFinset hf, by simp [hS]⟩⟩
 #align subgroup.fg_iff Subgroup.fg_iff
@@ -354,7 +354,7 @@ theorem Subgroup.fg_iff (P : Subgroup G) :
 /-- A subgroup is finitely generated if and only if it is finitely generated as a submonoid. -/
 @[to_additive AddSubgroup.fg_iff_addSubmonoid_fg
       "An additive subgroup is finitely generated if\nand only if it is finitely generated as an additive submonoid."]
-theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.Fg ↔ P.toSubmonoid.Fg :=
+theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.FG :=
   by
   constructor
   · rintro ⟨S, rfl⟩
@@ -373,11 +373,11 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.Fg ↔ P.toSubmonoid.F
 
 /- warning: subgroup.fg_iff_add_fg -> Subgroup.fg_iff_add_fg is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.Fg.{u1} G _inst_3 P) (AddSubgroup.Fg.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)))) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))))) (fun (_x : RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) => (Subgroup.{u1} G _inst_3) -> (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (RelIso.hasCoeToFun.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)))) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))))) (fun (_x : RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) => (Subgroup.{u1} G _inst_3) -> (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (RelIso.hasCoeToFun.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.Fg.{u1} G _inst_3 P) (AddSubgroup.Fg.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.FG.{u1} G _inst_3 P) (AddSubgroup.FG.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 Case conversion may be inaccurate. Consider using '#align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fgₓ'. -/
-theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.Fg ↔ P.toAddSubgroup.Fg :=
+theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG :=
   by
   rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.fg_iff_addSubmonoid_fg]
   exact (Subgroup.toSubmonoid P).fg_iff_add_fg
@@ -385,11 +385,11 @@ theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.Fg ↔ P.toAddSubgroup.Fg :=
 
 /- warning: add_subgroup.fg_iff_mul_fg -> AddSubgroup.fg_iff_mul_fg is a dubious translation:
 lean 3 declaration is
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.Fg.{u1} H _inst_4 P) (Subgroup.Fg.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4)))) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))))) (fun (_x : RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) => (AddSubgroup.{u1} H _inst_4) -> (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (RelIso.hasCoeToFun.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
+  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4)))) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))))) (fun (_x : RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) => (AddSubgroup.{u1} H _inst_4) -> (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (RelIso.hasCoeToFun.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 but is expected to have type
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.Fg.{u1} H _inst_4 P) (Subgroup.Fg.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
+  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.FG.{u1} H _inst_4 P) (Subgroup.FG.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 Case conversion may be inaccurate. Consider using '#align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fgₓ'. -/
-theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.Fg ↔ P.toSubgroup.Fg :=
+theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG :=
   by
   rw [AddSubgroup.fg_iff_addSubmonoid_fg, Subgroup.fg_iff_submonoid_fg]
   exact AddSubmonoid.fg_iff_mul_fg (AddSubgroup.toAddSubmonoid P)
@@ -401,68 +401,68 @@ section Group
 
 variable (G H)
 
-#print Group.Fg /-
+#print Group.FG /-
 /-- A group is finitely generated if it is finitely generated as a submonoid of itself. -/
-class Group.Fg : Prop where
-  out : (⊤ : Subgroup G).Fg
-#align group.fg Group.Fg
+class Group.FG : Prop where
+  out : (⊤ : Subgroup G).FG
+#align group.fg Group.FG
 -/
 
-#print AddGroup.Fg /-
+#print AddGroup.FG /-
 /-- An additive group is finitely generated if it is finitely generated as an additive submonoid of
 itself. -/
-class AddGroup.Fg : Prop where
-  out : (⊤ : AddSubgroup H).Fg
-#align add_group.fg AddGroup.Fg
+class AddGroup.FG : Prop where
+  out : (⊤ : AddSubgroup H).FG
+#align add_group.fg AddGroup.FG
 -/
 
-attribute [to_additive] Group.Fg
+attribute [to_additive] Group.FG
 
 variable {G H}
 
 /- warning: group.fg_def -> Group.fg_def is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.Fg.{u1} G _inst_3) (Subgroup.Fg.{u1} G _inst_3 (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3)))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Subgroup.FG.{u1} G _inst_3 (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3)))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.Fg.{u1} G _inst_3) (Subgroup.Fg.{u1} G _inst_3 (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3)))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Subgroup.FG.{u1} G _inst_3 (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3)))
 Case conversion may be inaccurate. Consider using '#align group.fg_def Group.fg_defₓ'. -/
-theorem Group.fg_def : Group.Fg G ↔ (⊤ : Subgroup G).Fg :=
+theorem Group.fg_def : Group.FG G ↔ (⊤ : Subgroup G).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align group.fg_def Group.fg_def
 
 /- warning: add_group.fg_def -> AddGroup.fg_def is a dubious translation:
 lean 3 declaration is
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H], Iff (AddGroup.Fg.{u1} H _inst_4) (AddSubgroup.Fg.{u1} H _inst_4 (Top.top.{u1} (AddSubgroup.{u1} H _inst_4) (AddSubgroup.hasTop.{u1} H _inst_4)))
+  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H], Iff (AddGroup.FG.{u1} H _inst_4) (AddSubgroup.FG.{u1} H _inst_4 (Top.top.{u1} (AddSubgroup.{u1} H _inst_4) (AddSubgroup.hasTop.{u1} H _inst_4)))
 but is expected to have type
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H], Iff (AddGroup.Fg.{u1} H _inst_4) (AddSubgroup.Fg.{u1} H _inst_4 (Top.top.{u1} (AddSubgroup.{u1} H _inst_4) (AddSubgroup.instTopAddSubgroup.{u1} H _inst_4)))
+  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H], Iff (AddGroup.FG.{u1} H _inst_4) (AddSubgroup.FG.{u1} H _inst_4 (Top.top.{u1} (AddSubgroup.{u1} H _inst_4) (AddSubgroup.instTopAddSubgroup.{u1} H _inst_4)))
 Case conversion may be inaccurate. Consider using '#align add_group.fg_def AddGroup.fg_defₓ'. -/
-theorem AddGroup.fg_def : AddGroup.Fg H ↔ (⊤ : AddSubgroup H).Fg :=
+theorem AddGroup.fg_def : AddGroup.FG H ↔ (⊤ : AddSubgroup H).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_group.fg_def AddGroup.fg_def
 
 /- warning: group.fg_iff -> Group.fg_iff is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.Fg.{u1} G _inst_3) (Exists.{succ u1} (Set.{u1} G) (fun (S : Set.{u1} G) => And (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 S) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))) (Set.Finite.{u1} G S)))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{succ u1} (Set.{u1} G) (fun (S : Set.{u1} G) => And (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 S) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))) (Set.Finite.{u1} G S)))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.Fg.{u1} G _inst_3) (Exists.{succ u1} (Set.{u1} G) (fun (S : Set.{u1} G) => And (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 S) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))) (Set.Finite.{u1} G S)))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{succ u1} (Set.{u1} G) (fun (S : Set.{u1} G) => And (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 S) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))) (Set.Finite.{u1} G S)))
 Case conversion may be inaccurate. Consider using '#align group.fg_iff Group.fg_iffₓ'. -/
 /-- An equivalent expression of `group.fg` in terms of `set.finite` instead of `finset`. -/
 @[to_additive
       "An equivalent expression of `add_group.fg` in terms of `set.finite` instead of\n`finset`."]
-theorem Group.fg_iff : Group.Fg G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ : Subgroup G) ∧ S.Finite :=
+theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ : Subgroup G) ∧ S.Finite :=
   ⟨fun h => (Subgroup.fg_iff ⊤).1 h.out, fun h => ⟨(Subgroup.fg_iff ⊤).2 h⟩⟩
 #align group.fg_iff Group.fg_iff
 #align add_group.fg_iff AddGroup.fg_iff
 
 /- warning: group.fg_iff' -> Group.fg_iff' is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.Fg.{u1} G _inst_3) (Exists.{1} Nat (fun (n : Nat) => Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) n) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))))))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{1} Nat (fun (n : Nat) => Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) n) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))))))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.Fg.{u1} G _inst_3) (Exists.{1} Nat (fun (n : Nat) => Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) n) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))))))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Iff (Group.FG.{u1} G _inst_3) (Exists.{1} Nat (fun (n : Nat) => Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) n) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))))))
 Case conversion may be inaccurate. Consider using '#align group.fg_iff' Group.fg_iff'ₓ'. -/
 @[to_additive]
 theorem Group.fg_iff' :
-    Group.Fg G ↔ ∃ (n : _)(S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
+    Group.FG G ↔ ∃ (n : _)(S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
   Group.fg_def.trans ⟨fun ⟨S, hS⟩ => ⟨S.card, S, rfl, hS⟩, fun ⟨n, S, hn, hS⟩ => ⟨S, hS⟩⟩
 #align group.fg_iff' Group.fg_iff'
 #align add_group.fg_iff' AddGroup.fg_iff'
@@ -471,41 +471,41 @@ theorem Group.fg_iff' :
 /-- A group is finitely generated if and only if it is finitely generated as a monoid. -/
 @[to_additive AddGroup.fg_iff_addMonoid_fg
       "An additive group is finitely generated if and only\nif it is finitely generated as an additive monoid."]
-theorem Group.fg_iff_monoid_fg : Group.Fg G ↔ Monoid.Fg G :=
+theorem Group.fg_iff_monoid_fg : Group.FG G ↔ Monoid.FG G :=
   ⟨fun h => Monoid.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).1 (Group.fg_def.1 h), fun h =>
     Group.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).2 (Monoid.fg_def.1 h)⟩
 #align group.fg_iff_monoid.fg Group.fg_iff_monoid_fg
 #align add_group.fg_iff_add_monoid.fg AddGroup.fg_iff_addMonoid_fg
 -/
 
-#print GroupFg.iff_add_fg /-
-theorem GroupFg.iff_add_fg : Group.Fg G ↔ AddGroup.Fg (Additive G) :=
+#print GroupFG.iff_add_fg /-
+theorem GroupFG.iff_add_fg : Group.FG G ↔ AddGroup.FG (Additive G) :=
   ⟨fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).1 h.out⟩, fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).2 h.out⟩⟩
-#align group_fg.iff_add_fg GroupFg.iff_add_fg
+#align group_fg.iff_add_fg GroupFG.iff_add_fg
 -/
 
 #print AddGroup.fg_iff_mul_fg /-
-theorem AddGroup.fg_iff_mul_fg : AddGroup.Fg H ↔ Group.Fg (Multiplicative H) :=
+theorem AddGroup.fg_iff_mul_fg : AddGroup.FG H ↔ Group.FG (Multiplicative H) :=
   ⟨fun h => ⟨(AddSubgroup.fg_iff_mul_fg ⊤).1 h.out⟩, fun h =>
     ⟨(AddSubgroup.fg_iff_mul_fg ⊤).2 h.out⟩⟩
 #align add_group.fg_iff_mul_fg AddGroup.fg_iff_mul_fg
 -/
 
 #print AddGroup.fg_of_group_fg /-
-instance AddGroup.fg_of_group_fg [Group.Fg G] : AddGroup.Fg (Additive G) :=
-  GroupFg.iff_add_fg.1 ‹_›
+instance AddGroup.fg_of_group_fg [Group.FG G] : AddGroup.FG (Additive G) :=
+  GroupFG.iff_add_fg.1 ‹_›
 #align add_group.fg_of_group_fg AddGroup.fg_of_group_fg
 -/
 
 #print Group.fg_of_mul_group_fg /-
-instance Group.fg_of_mul_group_fg [AddGroup.Fg H] : Group.Fg (Multiplicative H) :=
+instance Group.fg_of_mul_group_fg [AddGroup.FG H] : Group.FG (Multiplicative H) :=
   AddGroup.fg_iff_mul_fg.1 ‹_›
 #align group.fg_of_mul_group_fg Group.fg_of_mul_group_fg
 -/
 
 #print Group.fg_of_finite /-
 @[to_additive]
-instance (priority := 100) Group.fg_of_finite [Finite G] : Group.Fg G :=
+instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G :=
   by
   cases nonempty_fintype G
   exact ⟨⟨Finset.univ, by rw [Finset.coe_univ] <;> exact Subgroup.closure_univ⟩⟩
@@ -515,13 +515,13 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.Fg G :=
 
 /- warning: group.fg_of_surjective -> Group.fg_of_surjective is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (Group.Fg.{u2} G' _inst_5)
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (Group.FG.{u2} G' _inst_5)
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.Fg.{u2} G' _inst_5)
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.FG.{u2} G' _inst_5)
 Case conversion may be inaccurate. Consider using '#align group.fg_of_surjective Group.fg_of_surjectiveₓ'. -/
 @[to_additive]
-theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.Fg G] {f : G →* G'}
-    (hf : Function.Surjective f) : Group.Fg G' :=
+theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G →* G'}
+    (hf : Function.Surjective f) : Group.FG G' :=
   Group.fg_iff_monoid_fg.mpr <|
     @Monoid.fg_of_surjective G _ G' _ (Group.fg_iff_monoid_fg.mp hG) f hf
 #align group.fg_of_surjective Group.fg_of_surjective
@@ -529,24 +529,24 @@ theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.Fg G] {f : G
 
 /- warning: group.fg_range -> Group.fg_range is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.Fg.{u1} G _inst_3] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), Group.Fg.{u2} (coeSort.{succ u2, succ (succ u2)} (Subgroup.{u2} G' _inst_5) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.setLike.{u2} G' _inst_5)) (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), Group.FG.{u2} (coeSort.{succ u2, succ (succ u2)} (Subgroup.{u2} G' _inst_5) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.setLike.{u2} G' _inst_5)) (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.Fg.{u1} G _inst_3] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), Group.Fg.{u2} (Subtype.{succ u2} G' (fun (x : G') => Membership.mem.{u2, u2} G' (Subgroup.{u2} G' _inst_5) (SetLike.instMembership.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.instSetLikeSubgroup.{u2} G' _inst_5)) x (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), Group.FG.{u2} (Subtype.{succ u2} G' (fun (x : G') => Membership.mem.{u2, u2} G' (Subgroup.{u2} G' _inst_5) (SetLike.instMembership.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.instSetLikeSubgroup.{u2} G' _inst_5)) x (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f))
 Case conversion may be inaccurate. Consider using '#align group.fg_range Group.fg_rangeₓ'. -/
 @[to_additive]
-instance Group.fg_range {G' : Type _} [Group G'] [Group.Fg G] (f : G →* G') : Group.Fg f.range :=
+instance Group.fg_range {G' : Type _} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range :=
   Group.fg_of_surjective f.rangeRestrict_surjective
 #align group.fg_range Group.fg_range
 #align add_group.fg_range AddGroup.fg_range
 
 /- warning: group.closure_finset_fg -> Group.closure_finset_fg is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), Group.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s)))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) s)))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), Group.Fg.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s)))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s)))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Finset.{u1} G), Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s)))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G s)))
 Case conversion may be inaccurate. Consider using '#align group.closure_finset_fg Group.closure_finset_fgₓ'. -/
 @[to_additive]
-instance Group.closure_finset_fg (s : Finset G) : Group.Fg (Subgroup.closure (s : Set G)) :=
+instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s : Set G)) :=
   by
   refine' ⟨⟨s.preimage coe (subtype.coe_injective.inj_on _), _⟩⟩
   rw [Finset.coe_preimage, ← Subgroup.coeSubtype, Subgroup.closure_preimage_eq_top]
@@ -555,12 +555,12 @@ instance Group.closure_finset_fg (s : Finset G) : Group.Fg (Subgroup.closure (s
 
 /- warning: group.closure_finite_fg -> Group.closure_finite_fg is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) s)], Group.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 s)) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (coeSort.{succ u1, succ (succ u1)} (Set.{u1} G) Type.{u1} (Set.hasCoeToSort.{u1} G) s)], Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) (Subgroup.closure.{u1} G _inst_3 s)) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (Set.Elem.{u1} G s)], Group.Fg.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G) [_inst_5 : Finite.{succ u1} (Set.Elem.{u1} G s)], Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x (Subgroup.closure.{u1} G _inst_3 s))) (Subgroup.toGroup.{u1} G _inst_3 (Subgroup.closure.{u1} G _inst_3 s))
 Case conversion may be inaccurate. Consider using '#align group.closure_finite_fg Group.closure_finite_fgₓ'. -/
 @[to_additive]
-instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.Fg (Subgroup.closure s) :=
+instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.FG (Subgroup.closure s) :=
   haveI := Fintype.ofFinite s
   s.coe_to_finset ▸ Group.closure_finset_fg s.to_finset
 #align group.closure_finite_fg Group.closure_finite_fg
@@ -571,7 +571,7 @@ variable (G)
 #print Group.rank /-
 /-- The minimum number of generators of a group. -/
 @[to_additive "The minimum number of generators of an additive group"]
-noncomputable def Group.rank [h : Group.Fg G] :=
+noncomputable def Group.rank [h : Group.FG G] :=
   @Nat.find _ (Classical.decPred _) (Group.fg_iff'.mp h)
 #align group.rank Group.rank
 #align add_group.rank AddGroup.rank
@@ -579,12 +579,12 @@ noncomputable def Group.rank [h : Group.Fg G] :=
 
 /- warning: group.rank_spec -> Group.rank_spec is a dubious translation:
 lean 3 declaration is
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.Fg.{u1} G _inst_3], Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) (Group.rank.{u1} G _inst_3 h)) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))))
+  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3], Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) (Group.rank.{u1} G _inst_3 h)) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))))
 but is expected to have type
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.Fg.{u1} G _inst_3], Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) (Group.rank.{u1} G _inst_3 h)) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))))
+  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3], Exists.{succ u1} (Finset.{u1} G) (fun (S : Finset.{u1} G) => And (Eq.{1} Nat (Finset.card.{u1} G S) (Group.rank.{u1} G _inst_3 h)) (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))))
 Case conversion may be inaccurate. Consider using '#align group.rank_spec Group.rank_specₓ'. -/
 @[to_additive]
-theorem Group.rank_spec [h : Group.Fg G] :
+theorem Group.rank_spec [h : Group.FG G] :
     ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ :=
   @Nat.find_spec _ (Classical.decPred _) (Group.fg_iff'.mp h)
 #align group.rank_spec Group.rank_spec
@@ -592,12 +592,12 @@ theorem Group.rank_spec [h : Group.Fg G] :
 
 /- warning: group.rank_le -> Group.rank_le is a dubious translation:
 lean 3 declaration is
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.Fg.{u1} G _inst_3] {S : Finset.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u1} G _inst_3 h) (Finset.card.{u1} G S))
+  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3] {S : Finset.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Finset.{u1} G) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Finset.{u1} G) (Set.{u1} G) (Finset.Set.hasCoeT.{u1} G))) S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.hasTop.{u1} G _inst_3))) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u1} G _inst_3 h) (Finset.card.{u1} G S))
 but is expected to have type
-  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.Fg.{u1} G _inst_3] {S : Finset.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G _inst_3 h) (Finset.card.{u1} G S))
+  forall (G : Type.{u1}) [_inst_3 : Group.{u1} G] [h : Group.FG.{u1} G _inst_3] {S : Finset.{u1} G}, (Eq.{succ u1} (Subgroup.{u1} G _inst_3) (Subgroup.closure.{u1} G _inst_3 (Finset.toSet.{u1} G S)) (Top.top.{u1} (Subgroup.{u1} G _inst_3) (Subgroup.instTopSubgroup.{u1} G _inst_3))) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G _inst_3 h) (Finset.card.{u1} G S))
 Case conversion may be inaccurate. Consider using '#align group.rank_le Group.rank_leₓ'. -/
 @[to_additive]
-theorem Group.rank_le [h : Group.Fg G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
+theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
     Group.rank G ≤ S.card :=
   @Nat.find_le _ _ (Classical.decPred _) (Group.fg_iff'.mp h) ⟨S, rfl, hS⟩
 #align group.rank_le Group.rank_le
@@ -607,12 +607,12 @@ variable {G} {G' : Type _} [Group G']
 
 /- warning: group.rank_le_of_surjective -> Group.rank_le_of_surjective is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.Fg.{u1} G _inst_3] [_inst_7 : Group.Fg.{u2} G' _inst_5] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} G' _inst_5 _inst_7) (Group.rank.{u1} G _inst_3 _inst_6))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] [_inst_7 : Group.FG.{u2} G' _inst_5] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} G' _inst_5 _inst_7) (Group.rank.{u1} G _inst_3 _inst_6))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.Fg.{u2} G _inst_3] [_inst_7 : Group.Fg.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
+  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] [_inst_7 : Group.FG.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
 Case conversion may be inaccurate. Consider using '#align group.rank_le_of_surjective Group.rank_le_of_surjectiveₓ'. -/
 @[to_additive]
-theorem Group.rank_le_of_surjective [Group.Fg G] [Group.Fg G'] (f : G →* G')
+theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
     (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by
   classical
     obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
@@ -625,24 +625,24 @@ theorem Group.rank_le_of_surjective [Group.Fg G] [Group.Fg G'] (f : G →* G')
 
 /- warning: group.rank_range_le -> Group.rank_range_le is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} (coeSort.{succ u2, succ (succ u2)} (Subgroup.{u2} G' _inst_5) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.setLike.{u2} G' _inst_5)) (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Group.fg_range.{u1, u2} G _inst_3 G' _inst_5 _inst_6 f)) (Group.rank.{u1} G _inst_3 _inst_6)
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} (coeSort.{succ u2, succ (succ u2)} (Subgroup.{u2} G' _inst_5) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Subgroup.{u2} G' _inst_5) G' (Subgroup.setLike.{u2} G' _inst_5)) (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Subgroup.toGroup.{u2} G' _inst_5 (MonoidHom.range.{u1, u2} G _inst_3 G' _inst_5 f)) (Group.fg_range.{u1, u2} G _inst_3 G' _inst_5 _inst_6 f)) (Group.rank.{u1} G _inst_3 _inst_6)
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.Fg.{u2} G _inst_3] {f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))}, LE.le.{0} Nat instLENat (Group.rank.{u1} (Subtype.{succ u1} G' (fun (x : G') => Membership.mem.{u1, u1} G' (Subgroup.{u1} G' _inst_5) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G' _inst_5) G' (Subgroup.instSetLikeSubgroup.{u1} G' _inst_5)) x (MonoidHom.range.{u2, u1} G _inst_3 G' _inst_5 f))) (Subgroup.toGroup.{u1} G' _inst_5 (MonoidHom.range.{u2, u1} G _inst_3 G' _inst_5 f)) (Group.fg_range.{u2, u1} G _inst_3 G' _inst_5 _inst_6 f)) (Group.rank.{u2} G _inst_3 _inst_6)
+  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] {f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))}, LE.le.{0} Nat instLENat (Group.rank.{u1} (Subtype.{succ u1} G' (fun (x : G') => Membership.mem.{u1, u1} G' (Subgroup.{u1} G' _inst_5) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G' _inst_5) G' (Subgroup.instSetLikeSubgroup.{u1} G' _inst_5)) x (MonoidHom.range.{u2, u1} G _inst_3 G' _inst_5 f))) (Subgroup.toGroup.{u1} G' _inst_5 (MonoidHom.range.{u2, u1} G _inst_3 G' _inst_5 f)) (Group.fg_range.{u2, u1} G _inst_3 G' _inst_5 _inst_6 f)) (Group.rank.{u2} G _inst_3 _inst_6)
 Case conversion may be inaccurate. Consider using '#align group.rank_range_le Group.rank_range_leₓ'. -/
 @[to_additive]
-theorem Group.rank_range_le [Group.Fg G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G :=
+theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G :=
   Group.rank_le_of_surjective f.range_restrict f.rangeRestrict_surjective
 #align group.rank_range_le Group.rank_range_le
 #align add_group.rank_range_le AddGroup.rank_range_le
 
 /- warning: group.rank_congr -> Group.rank_congr is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.Fg.{u1} G _inst_3] [_inst_7 : Group.Fg.{u2} G' _inst_5], (MulEquiv.{u1, u2} G G' (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toHasMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))))) -> (Eq.{1} Nat (Group.rank.{u1} G _inst_3 _inst_6) (Group.rank.{u2} G' _inst_5 _inst_7))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.FG.{u1} G _inst_3] [_inst_7 : Group.FG.{u2} G' _inst_5], (MulEquiv.{u1, u2} G G' (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toHasMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))))) -> (Eq.{1} Nat (Group.rank.{u1} G _inst_3 _inst_6) (Group.rank.{u2} G' _inst_5 _inst_7))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.Fg.{u2} G _inst_3] [_inst_7 : Group.Fg.{u1} G' _inst_5], (MulEquiv.{u2, u1} G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))))) -> (Eq.{1} Nat (Group.rank.{u2} G _inst_3 _inst_6) (Group.rank.{u1} G' _inst_5 _inst_7))
+  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.FG.{u2} G _inst_3] [_inst_7 : Group.FG.{u1} G' _inst_5], (MulEquiv.{u2, u1} G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))))) -> (Eq.{1} Nat (Group.rank.{u2} G _inst_3 _inst_6) (Group.rank.{u1} G' _inst_5 _inst_7))
 Case conversion may be inaccurate. Consider using '#align group.rank_congr Group.rank_congrₓ'. -/
 @[to_additive]
-theorem Group.rank_congr [Group.Fg G] [Group.Fg G'] (f : G ≃* G') : Group.rank G = Group.rank G' :=
+theorem Group.rank_congr [Group.FG G] [Group.FG G'] (f : G ≃* G') : Group.rank G = Group.rank G' :=
   le_antisymm (Group.rank_le_of_surjective f.symm f.symm.Surjective)
     (Group.rank_le_of_surjective f f.Surjective)
 #align group.rank_congr Group.rank_congr
@@ -654,12 +654,12 @@ namespace Subgroup
 
 /- warning: subgroup.rank_congr -> Subgroup.rank_congr is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {H : Subgroup.{u1} G _inst_3} {K : Subgroup.{u1} G _inst_3} [_inst_5 : Group.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) H) (Subgroup.toGroup.{u1} G _inst_3 H)] [_inst_6 : Group.Fg.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) K) (Subgroup.toGroup.{u1} G _inst_3 K)], (Eq.{succ u1} (Subgroup.{u1} G _inst_3) H K) -> (Eq.{1} Nat (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) H) (Subgroup.toGroup.{u1} G _inst_3 H) _inst_5) (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) K) (Subgroup.toGroup.{u1} G _inst_3 K) _inst_6))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {H : Subgroup.{u1} G _inst_3} {K : Subgroup.{u1} G _inst_3} [_inst_5 : Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) H) (Subgroup.toGroup.{u1} G _inst_3 H)] [_inst_6 : Group.FG.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) K) (Subgroup.toGroup.{u1} G _inst_3 K)], (Eq.{succ u1} (Subgroup.{u1} G _inst_3) H K) -> (Eq.{1} Nat (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) H) (Subgroup.toGroup.{u1} G _inst_3 H) _inst_5) (Group.rank.{u1} (coeSort.{succ u1, succ (succ u1)} (Subgroup.{u1} G _inst_3) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)) K) (Subgroup.toGroup.{u1} G _inst_3 K) _inst_6))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {H : Subgroup.{u1} G _inst_3} {K : Subgroup.{u1} G _inst_3} [_inst_5 : Group.Fg.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x H)) (Subgroup.toGroup.{u1} G _inst_3 H)] [_inst_6 : Group.Fg.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x K)) (Subgroup.toGroup.{u1} G _inst_3 K)], (Eq.{succ u1} (Subgroup.{u1} G _inst_3) H K) -> (Eq.{1} Nat (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x H)) (Subgroup.toGroup.{u1} G _inst_3 H) _inst_5) (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x K)) (Subgroup.toGroup.{u1} G _inst_3 K) _inst_6))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {H : Subgroup.{u1} G _inst_3} {K : Subgroup.{u1} G _inst_3} [_inst_5 : Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x H)) (Subgroup.toGroup.{u1} G _inst_3 H)] [_inst_6 : Group.FG.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x K)) (Subgroup.toGroup.{u1} G _inst_3 K)], (Eq.{succ u1} (Subgroup.{u1} G _inst_3) H K) -> (Eq.{1} Nat (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x H)) (Subgroup.toGroup.{u1} G _inst_3 H) _inst_5) (Group.rank.{u1} (Subtype.{succ u1} G (fun (x : G) => Membership.mem.{u1, u1} G (Subgroup.{u1} G _inst_3) (SetLike.instMembership.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)) x K)) (Subgroup.toGroup.{u1} G _inst_3 K) _inst_6))
 Case conversion may be inaccurate. Consider using '#align subgroup.rank_congr Subgroup.rank_congrₓ'. -/
 @[to_additive]
-theorem rank_congr {H K : Subgroup G} [Group.Fg H] [Group.Fg K] (h : H = K) :
+theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
     Group.rank H = Group.rank K := by subst h
 #align subgroup.rank_congr Subgroup.rank_congr
 #align add_subgroup.rank_congr AddSubgroup.rank_congr
@@ -707,7 +707,7 @@ section QuotientGroup
 
 #print QuotientGroup.fg /-
 @[to_additive]
-instance QuotientGroup.fg [Group.Fg G] (N : Subgroup G) [Subgroup.Normal N] : Group.Fg <| G ⧸ N :=
+instance QuotientGroup.fg [Group.FG G] (N : Subgroup G) [Subgroup.Normal N] : Group.FG <| G ⧸ N :=
   Group.fg_of_surjective <| QuotientGroup.mk'_surjective N
 #align quotient_group.fg QuotientGroup.fg
 #align quotient_add_group.fg QuotientAddGroup.fg

mathlib commit https://github.com/leanprover-community/mathlib/commit/730c6d4cab72b9d84fcfb9e95e8796e9cd8f40ba

@@ -74,7 +74,7 @@ theorem Submonoid.fg_iff (P : Submonoid M) :
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.Fg.{u1} M _inst_1 P) (AddSubmonoid.Fg.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (fun (_x : RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) => (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) -> (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (RelIso.hasCoeToFun.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.Fg.{u1} M _inst_1 P) (AddSubmonoid.Fg.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))) (RelEmbedding.toEmbedding.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) P))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Iff (Submonoid.Fg.{u1} M _inst_1 P) (AddSubmonoid.Fg.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (fun (_x : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) => LE.le.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Preorder.toLE.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) => LE.le.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} (Additive.{u1} M) (Additive.addZeroClass.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Submonoid.toAddSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) P))
 Case conversion may be inaccurate. Consider using '#align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fgₓ'. -/
 theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.Fg ↔ P.toAddSubmonoid.Fg :=
   ⟨fun h =>
@@ -91,7 +91,7 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.Fg ↔ P.toAddSubmonoid.Fg
 lean 3 declaration is
   forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.Fg.{u1} N _inst_2 P) (Submonoid.Fg.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) (fun (_x : RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) => (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) -> (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (RelIso.hasCoeToFun.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) N (AddSubmonoid.setLike.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) (LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Multiplicative.{u1} N) (Submonoid.setLike.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 but is expected to have type
-  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.Fg.{u1} N _inst_2 P) (Submonoid.Fg.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))) (RelEmbedding.toEmbedding.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))) P))
+  forall {N : Type.{u1}} [_inst_2 : AddMonoid.{u1} N] (P : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)), Iff (AddSubmonoid.Fg.{u1} N _inst_2 P) (Submonoid.Fg.{u1} (Multiplicative.{u1} N) (Multiplicative.monoid.{u1} N _inst_2) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (fun (_x : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) => LE.le.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)))))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) => LE.le.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Preorder.toLE.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))) (Submonoid.instCompleteLatticeSubmonoid.{u1} (Multiplicative.{u1} N) (Multiplicative.mulOneClass.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2))))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubmonoid.toSubmonoid.{u1} N (AddMonoid.toAddZeroClass.{u1} N _inst_2)) P))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fgₓ'. -/
 theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.Fg ↔ P.toSubmonoid.Fg :=
   by
@@ -375,7 +375,7 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.Fg ↔ P.toSubmonoid.F
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.Fg.{u1} G _inst_3 P) (AddSubgroup.Fg.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3)))) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))))) (fun (_x : RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) => (Subgroup.{u1} G _inst_3) -> (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (RelIso.hasCoeToFun.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.setLike.{u1} G _inst_3))))) (LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.setLike.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.Fg.{u1} G _inst_3 P) (AddSubgroup.Fg.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)))) (RelEmbedding.toEmbedding.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (Subgroup.toAddSubgroup.{u1} G _inst_3))) P))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (P : Subgroup.{u1} G _inst_3), Iff (Subgroup.Fg.{u1} G _inst_3 P) (AddSubgroup.Fg.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (fun (_x : Subgroup.{u1} G _inst_3) => AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (Subgroup.{u1} G _inst_3) (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : Subgroup.{u1} G _inst_3) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : Subgroup.{u1} G _inst_3) => LE.le.{u1} (Subgroup.{u1} G _inst_3) (Preorder.toLE.{u1} (Subgroup.{u1} G _inst_3) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} G _inst_3) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} G _inst_3) G (Subgroup.instSetLikeSubgroup.{u1} G _inst_3)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) => LE.le.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Preorder.toLE.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3)) (Additive.{u1} G) (AddSubgroup.instSetLikeAddSubgroup.{u1} (Additive.{u1} G) (Additive.addGroup.{u1} G _inst_3))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (Subgroup.toAddSubgroup.{u1} G _inst_3) P))
 Case conversion may be inaccurate. Consider using '#align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fgₓ'. -/
 theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.Fg ↔ P.toAddSubgroup.Fg :=
   by
@@ -387,7 +387,7 @@ theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.Fg ↔ P.toAddSubgroup.Fg :=
 lean 3 declaration is
   forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.Fg.{u1} H _inst_4 P) (Subgroup.Fg.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (coeFn.{succ u1, succ u1} (OrderIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4)))) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))))) (fun (_x : RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) => (AddSubgroup.{u1} H _inst_4) -> (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (RelIso.hasCoeToFun.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.partialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.setLike.{u1} H _inst_4))))) (LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.partialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.setLike.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 but is expected to have type
-  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.Fg.{u1} H _inst_4 P) (Subgroup.Fg.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => (fun (x._@.Mathlib.Data.FunLike.Embedding._hyg.19 : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) _x) (EmbeddingLike.toFunLike.{succ u1, succ u1, succ u1} (Function.Embedding.{succ u1, succ u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Function.instEmbeddingLikeEmbedding.{succ u1, succ u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)))) (RelEmbedding.toEmbedding.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.toRelEmbedding.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (AddSubgroup.toSubgroup.{u1} H _inst_4))) P))
+  forall {H : Type.{u1}} [_inst_4 : AddGroup.{u1} H] (P : AddSubgroup.{u1} H _inst_4), Iff (AddSubgroup.Fg.{u1} H _inst_4 P) (Subgroup.Fg.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4) (FunLike.coe.{succ u1, succ u1, succ u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (fun (_x : AddSubgroup.{u1} H _inst_4) => Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (RelHomClass.toFunLike.{u1, u1, u1} (RelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298)) (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298) (RelIso.instRelHomClassRelIso.{u1, u1} (AddSubgroup.{u1} H _inst_4) (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1281 : AddSubgroup.{u1} H _inst_4) (x._@.Mathlib.Order.Hom.Basic._hyg.1283 : AddSubgroup.{u1} H _inst_4) => LE.le.{u1} (AddSubgroup.{u1} H _inst_4) (Preorder.toLE.{u1} (AddSubgroup.{u1} H _inst_4) (PartialOrder.toPreorder.{u1} (AddSubgroup.{u1} H _inst_4) (SetLike.instPartialOrder.{u1, u1} (AddSubgroup.{u1} H _inst_4) H (AddSubgroup.instSetLikeAddSubgroup.{u1} H _inst_4)))) x._@.Mathlib.Order.Hom.Basic._hyg.1281 x._@.Mathlib.Order.Hom.Basic._hyg.1283) (fun (x._@.Mathlib.Order.Hom.Basic._hyg.1296 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (x._@.Mathlib.Order.Hom.Basic._hyg.1298 : Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) => LE.le.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Preorder.toLE.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (PartialOrder.toPreorder.{u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (SetLike.instPartialOrder.{u1, u1} (Subgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4)) (Multiplicative.{u1} H) (Subgroup.instSetLikeSubgroup.{u1} (Multiplicative.{u1} H) (Multiplicative.group.{u1} H _inst_4))))) x._@.Mathlib.Order.Hom.Basic._hyg.1296 x._@.Mathlib.Order.Hom.Basic._hyg.1298))) (AddSubgroup.toSubgroup.{u1} H _inst_4) P))
 Case conversion may be inaccurate. Consider using '#align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fgₓ'. -/
 theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.Fg ↔ P.toSubgroup.Fg :=
   by

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

@@ -95,7 +95,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fgₓ'. -/
 theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.Fg ↔ P.toSubmonoid.Fg :=
   by
-  convert (Submonoid.fg_iff_add_fg P.to_submonoid).symm
+  convert(Submonoid.fg_iff_add_fg P.to_submonoid).symm
   exact SetLike.ext' rfl
 #align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fg
 

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

@@ -211,7 +211,7 @@ theorem Submonoid.Fg.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.Fg)
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
 Case conversion may be inaccurate. Consider using '#align submonoid.fg.map_injective Submonoid.Fg.map_injectiveₓ'. -/
 @[to_additive]
 theorem Submonoid.Fg.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
@@ -245,7 +245,7 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.Fg N ↔ N.Fg :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) -> (Monoid.Fg.{u2} M' _inst_3)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.Fg.{u2} M' _inst_3)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.Fg.{u2} M' _inst_3)
 Case conversion may be inaccurate. Consider using '#align monoid.fg_of_surjective Monoid.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M →* M')
@@ -517,7 +517,7 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.Fg G :=
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (Group.Fg.{u2} G' _inst_5)
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.Fg.{u2} G' _inst_5)
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.Fg.{u2} G' _inst_5)
 Case conversion may be inaccurate. Consider using '#align group.fg_of_surjective Group.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.Fg G] {f : G →* G'}
@@ -609,7 +609,7 @@ variable {G} {G' : Type _} [Group G']
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.Fg.{u1} G _inst_3] [_inst_7 : Group.Fg.{u2} G' _inst_5] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} G' _inst_5 _inst_7) (Group.rank.{u1} G _inst_3 _inst_6))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.Fg.{u2} G _inst_3] [_inst_7 : Group.Fg.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
+  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.Fg.{u2} G _inst_3] [_inst_7 : Group.Fg.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
 Case conversion may be inaccurate. Consider using '#align group.rank_le_of_surjective Group.rank_le_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.Fg G] [Group.Fg G'] (f : G →* G')

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

@@ -211,7 +211,7 @@ theorem Submonoid.Fg.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.Fg)
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u2 u1} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} (e : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Injective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) e)) -> (Submonoid.Fg.{u2} M' _inst_3 (Submonoid.map.{u1, u2, max u1 u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) e P)) -> (Submonoid.Fg.{u1} M _inst_1 P)
 Case conversion may be inaccurate. Consider using '#align submonoid.fg.map_injective Submonoid.Fg.map_injectiveₓ'. -/
 @[to_additive]
 theorem Submonoid.Fg.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
@@ -245,7 +245,7 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.Fg N ↔ N.Fg :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) (fun (_x : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) => M -> M') (MonoidHom.hasCoeToFun.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) f)) -> (Monoid.Fg.{u2} M' _inst_3)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.Fg.{u2} M' _inst_3)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {M' : Type.{u2}} [_inst_3 : Monoid.{u2} M'] [_inst_4 : Monoid.Fg.{u1} M _inst_1] (f : MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)), (Function.Surjective.{succ u1, succ u2} M M' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => M') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u2} M' (Monoid.toMulOneClass.{u2} M' _inst_3)) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)) M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3) (MonoidHom.monoidHomClass.{u1, u2} M M' (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} M' _inst_3)))) f)) -> (Monoid.Fg.{u2} M' _inst_3)
 Case conversion may be inaccurate. Consider using '#align monoid.fg_of_surjective Monoid.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M →* M')
@@ -517,7 +517,7 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.Fg G :=
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (Group.Fg.{u2} G' _inst_5)
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.Fg.{u2} G' _inst_5)
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [hG : Group.Fg.{u1} G _inst_3] {f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))}, (Function.Surjective.{succ u1, succ u2} G G' (FunLike.coe.{max (succ u1) (succ u2), succ u1, succ u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => G') _x) (MulHomClass.toFunLike.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (MulOneClass.toMul.{u2} G' (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u1 u2, u1, u2} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5))) (MonoidHom.monoidHomClass.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))))) f)) -> (Group.Fg.{u2} G' _inst_5)
 Case conversion may be inaccurate. Consider using '#align group.fg_of_surjective Group.fg_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.Fg G] {f : G →* G'}
@@ -609,7 +609,7 @@ variable {G} {G' : Type _} [Group G']
 lean 3 declaration is
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {G' : Type.{u2}} [_inst_5 : Group.{u2} G'] [_inst_6 : Group.Fg.{u1} G _inst_3] [_inst_7 : Group.Fg.{u2} G' _inst_5] (f : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))), (Function.Surjective.{succ u1, succ u2} G G' (coeFn.{max (succ u2) (succ u1), max (succ u1) (succ u2)} (MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) (fun (_x : MonoidHom.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) => G -> G') (MonoidHom.hasCoeToFun.{u1, u2} G G' (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Monoid.toMulOneClass.{u2} G' (DivInvMonoid.toMonoid.{u2} G' (Group.toDivInvMonoid.{u2} G' _inst_5)))) f)) -> (LE.le.{0} Nat Nat.hasLe (Group.rank.{u2} G' _inst_5 _inst_7) (Group.rank.{u1} G _inst_3 _inst_6))
 but is expected to have type
-  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.Fg.{u2} G _inst_3] [_inst_7 : Group.Fg.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
+  forall {G : Type.{u2}} [_inst_3 : Group.{u2} G] {G' : Type.{u1}} [_inst_5 : Group.{u1} G'] [_inst_6 : Group.Fg.{u2} G _inst_3] [_inst_7 : Group.Fg.{u1} G' _inst_5] (f : MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))), (Function.Surjective.{succ u2, succ u1} G G' (FunLike.coe.{max (succ u2) (succ u1), succ u2, succ u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G (fun (_x : G) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : G) => G') _x) (MulHomClass.toFunLike.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3)))) (MulOneClass.toMul.{u1} G' (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) (MonoidHomClass.toMulHomClass.{max u2 u1, u2, u1} (MonoidHom.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))) G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5))) (MonoidHom.monoidHomClass.{u2, u1} G G' (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_3))) (Monoid.toMulOneClass.{u1} G' (DivInvMonoid.toMonoid.{u1} G' (Group.toDivInvMonoid.{u1} G' _inst_5)))))) f)) -> (LE.le.{0} Nat instLENat (Group.rank.{u1} G' _inst_5 _inst_7) (Group.rank.{u2} G _inst_3 _inst_6))
 Case conversion may be inaccurate. Consider using '#align group.rank_le_of_surjective Group.rank_le_of_surjectiveₓ'. -/
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.Fg G] [Group.Fg G'] (f : G →* G')

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

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

@@ -187,13 +187,13 @@ instance Monoid.fg_range {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M')
 #align monoid.fg_range Monoid.fg_range
 #align add_monoid.fg_range AddMonoid.fg_range
 
-@[to_additive AddSubmonoid.multiples_fg]
+@[to_additive]
 theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG :=
   ⟨{r}, (Finset.coe_singleton r).symm ▸ (Submonoid.powers_eq_closure r).symm⟩
 #align submonoid.powers_fg Submonoid.powers_fg
 #align add_submonoid.multiples_fg AddSubmonoid.multiples_fg
 
-@[to_additive AddMonoid.multiples_fg]
+@[to_additive]
 instance Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) :=
   (Monoid.fg_iff_submonoid_fg _).mpr (Submonoid.powers_fg r)
 #align monoid.powers_fg Monoid.powers_fg

No changes to tactic file, it's just boring fixes throughout the library.

This follows on from #6964.

Co-authored-by: sgouezel <sebastien.gouezel@univ-rennes1.fr> Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

@@ -442,15 +442,15 @@ theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
 @[to_additive]
 theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card := by
   classical
-    let t : Finset (closure (s : Set G)) := s.preimage Subtype.val (Subtype.coe_injective.injOn _)
-    have ht : closure (t : Set (closure (s : Set G))) = ⊤ := by
-      rw [Finset.coe_preimage]
-      exact closure_preimage_eq_top (s : Set G)
-    apply (Group.rank_le (closure (s : Set G)) ht).trans
-    suffices H : Set.InjOn Subtype.val (t : Set (closure (s : Set G)))
+  let t : Finset (closure (s : Set G)) := s.preimage Subtype.val (Subtype.coe_injective.injOn _)
+  have ht : closure (t : Set (closure (s : Set G))) = ⊤ := by
+    rw [Finset.coe_preimage]
+    exact closure_preimage_eq_top (s : Set G)
+  apply (Group.rank_le (closure (s : Set G)) ht).trans
+  suffices H : Set.InjOn Subtype.val (t : Set (closure (s : Set G))) by
     rw [← Finset.card_image_of_injOn H, Finset.image_preimage]
-    · apply Finset.card_filter_le
-    · apply Subtype.coe_injective.injOn
+    apply Finset.card_filter_le
+  apply Subtype.coe_injective.injOn
 #align subgroup.rank_closure_finset_le_card Subgroup.rank_closure_finset_le_card
 #align add_subgroup.rank_closure_finset_le_card AddSubgroup.rank_closure_finset_le_card
 

We prove the main characterisation of $\mathbb{Z}$-lattices: a subgroup $L$ of $\mathbb{R}^n$ that is discrete and that spans $\mathbb{R}^n$ is a free $\mathbb{Z}$-module of rank $n$ (in a slightly more general setting).

@@ -322,6 +322,11 @@ theorem Group.fg_iff_monoid_fg : Group.FG G ↔ Monoid.FG G :=
 #align group.fg_iff_monoid.fg Group.fg_iff_monoid_fg
 #align add_group.fg_iff_add_monoid.fg AddGroup.fg_iff_addMonoid_fg
 
+@[to_additive (attr := simp)]
+theorem Group.fg_iff_subgroup_fg (H : Subgroup G) : Group.FG H ↔ H.FG :=
+  (fg_iff_monoid_fg.trans (Monoid.fg_iff_submonoid_fg _)).trans
+    (Subgroup.fg_iff_submonoid_fg _).symm
+
 theorem GroupFG.iff_add_fg : Group.FG G ↔ AddGroup.FG (Additive G) :=
   ⟨fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).1 h.out⟩, fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).2 h.out⟩⟩
 #align group_fg.iff_add_fg GroupFG.iff_add_fg

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

This has nice performance benefits.

@@ -35,7 +35,7 @@ group.
 
 open Pointwise
 
-variable {M N : Type _} [Monoid M] [AddMonoid N]
+variable {M N : Type*} [Monoid M] [AddMonoid N]
 
 section Submonoid
 
@@ -140,7 +140,7 @@ instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.FG M := by
 end Monoid
 
 @[to_additive]
-theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
+theorem Submonoid.FG.map {M' : Type*} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
     (P.map e).FG := by
   classical
     obtain ⟨s, rfl⟩ := h
@@ -149,7 +149,7 @@ theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG)
 #align add_submonoid.fg.map AddSubmonoid.FG.map
 
 @[to_additive]
-theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
+theorem Submonoid.FG.map_injective {M' : Type*} [Monoid M'] {P : Submonoid M} (e : M →* M')
     (he : Function.Injective e) (h : (P.map e).FG) : P.FG := by
   obtain ⟨s, hs⟩ := h
   use s.preimage e (he.injOn _)
@@ -170,7 +170,7 @@ theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG := b
 #align add_monoid.fg_iff_add_submonoid_fg AddMonoid.fg_iff_addSubmonoid_fg
 
 @[to_additive]
-theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
+theorem Monoid.fg_of_surjective {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M')
     (hf : Function.Surjective f) : Monoid.FG M' := by
   classical
     obtain ⟨s, hs⟩ := Monoid.fg_def.mp ‹_›
@@ -181,7 +181,7 @@ theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M 
 #align add_monoid.fg_of_surjective AddMonoid.fg_of_surjective
 
 @[to_additive]
-instance Monoid.fg_range {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M') :
+instance Monoid.fg_range {M' : Type*} [Monoid M'] [Monoid.FG M] (f : M →* M') :
     Monoid.FG (MonoidHom.mrange f) :=
   Monoid.fg_of_surjective f.mrangeRestrict f.mrangeRestrict_surjective
 #align monoid.fg_range Monoid.fg_range
@@ -216,7 +216,7 @@ instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.
 /-! ### Groups and subgroups -/
 
 
-variable {G H : Type _} [Group G] [AddGroup H]
+variable {G H : Type*} [Group G] [AddGroup H]
 
 section Subgroup
 
@@ -347,7 +347,7 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G := by
 #align add_group.fg_of_finite AddGroup.fg_of_finite
 
 @[to_additive]
-theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G →* G'}
+theorem Group.fg_of_surjective {G' : Type*} [Group G'] [hG : Group.FG G] {f : G →* G'}
     (hf : Function.Surjective f) : Group.FG G' :=
   Group.fg_iff_monoid_fg.mpr <|
     @Monoid.fg_of_surjective G _ G' _ (Group.fg_iff_monoid_fg.mp hG) f hf
@@ -355,7 +355,7 @@ theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G
 #align add_group.fg_of_surjective AddGroup.fg_of_surjective
 
 @[to_additive]
-instance Group.fg_range {G' : Type _} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range :=
+instance Group.fg_range {G' : Type*} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range :=
   Group.fg_of_surjective f.rangeRestrict_surjective
 #align group.fg_range Group.fg_range
 #align add_group.fg_range AddGroup.fg_range
@@ -397,7 +397,7 @@ theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S
 #align group.rank_le Group.rank_le
 #align add_group.rank_le AddGroup.rank_le
 
-variable {G} {G' : Type _} [Group G']
+variable {G} {G' : Type*} [Group G']
 
 @[to_additive]
 theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Riccardo Brasca. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Riccardo Brasca
-
-! This file was ported from Lean 3 source module group_theory.finiteness
-! leanprover-community/mathlib commit dde670c9a3f503647fd5bfdf1037bad526d3397a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Pointwise.Finite
 import Mathlib.GroupTheory.QuotientGroup
@@ -15,6 +10,8 @@ import Mathlib.GroupTheory.Subgroup.Basic
 import Mathlib.SetTheory.Cardinal.Finite
 import Mathlib.Data.Finset.Preimage
 
+#align_import group_theory.finiteness from "leanprover-community/mathlib"@"dde670c9a3f503647fd5bfdf1037bad526d3397a"
+
 /-!
 # Finitely generated monoids and groups
 

This is the second half of the changes originally in #5699, removing all occurrences of ; after a space and implementing a linter rule to enforce it.

In most cases this 2-character substring has a space after it, so the following command was run first:

find . -type f -name "*.lean" -exec sed -i -E 's/ ; /; /g' {} \;

The remaining cases were few enough in number that they were done manually.

@@ -136,7 +136,7 @@ instance Monoid.fg_of_addMonoid_fg [AddMonoid.FG N] : Monoid.FG (Multiplicative
 @[to_additive]
 instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.FG M := by
   cases nonempty_fintype M
-  exact ⟨⟨Finset.univ, by rw [Finset.coe_univ] ; exact Submonoid.closure_univ⟩⟩
+  exact ⟨⟨Finset.univ, by rw [Finset.coe_univ]; exact Submonoid.closure_univ⟩⟩
 #align monoid.fg_of_finite Monoid.fg_of_finite
 #align add_monoid.fg_of_finite AddMonoid.fg_of_finite
 
@@ -345,7 +345,7 @@ instance Group.fg_of_mul_group_fg [AddGroup.FG H] : Group.FG (Multiplicative H)
 @[to_additive]
 instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G := by
   cases nonempty_fintype G
-  exact ⟨⟨Finset.univ, by rw [Finset.coe_univ] ; exact Subgroup.closure_univ⟩⟩
+  exact ⟨⟨Finset.univ, by rw [Finset.coe_univ]; exact Subgroup.closure_univ⟩⟩
 #align group.fg_of_finite Group.fg_of_finite
 #align add_group.fg_of_finite AddGroup.fg_of_finite
 

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Parcly Taxel <reddeloostw@gmail.com>

@@ -311,7 +311,7 @@ theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ :
 
 @[to_additive]
 theorem Group.fg_iff' :
-    Group.FG G ↔ ∃ (n : _)(S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
+    Group.FG G ↔ ∃ (n : _) (S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
   Group.fg_def.trans ⟨fun ⟨S, hS⟩ => ⟨S.card, S, rfl, hS⟩, fun ⟨_n, S, _hn, hS⟩ => ⟨S, hS⟩⟩
 #align group.fg_iff' Group.fg_iff'
 #align add_group.fg_iff' AddGroup.fg_iff'

Please refer to this Zulip thread: https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Naming.20convention/near/357712556

@@ -18,16 +18,16 @@ import Mathlib.Data.Finset.Preimage
 /-!
 # Finitely generated monoids and groups
 
-We define finitely generated monoids and groups. See also `Submodule.Fg` and `Module.Finite` for
+We define finitely generated monoids and groups. See also `Submodule.FG` and `Module.Finite` for
 finitely-generated modules.
 
 ## Main definition
 
-* `Submonoid.Fg S`, `AddSubmonoid.Fg S` : A submonoid `S` is finitely generated.
-* `Monoid.Fg M`, `AddMonoid.Fg M` : A typeclass indicating a type `M` is finitely generated as a
+* `Submonoid.FG S`, `AddSubmonoid.FG S` : A submonoid `S` is finitely generated.
+* `Monoid.FG M`, `AddMonoid.FG M` : A typeclass indicating a type `M` is finitely generated as a
 monoid.
-* `Subgroup.Fg S`, `AddSubgroup.Fg S` : A subgroup `S` is finitely generated.
-* `Group.Fg M`, `AddGroup.Fg M` : A typeclass indicating a type `M` is finitely generated as a
+* `Subgroup.FG S`, `AddSubgroup.FG S` : A subgroup `S` is finitely generated.
+* `Group.FG M`, `AddGroup.FG M` : A typeclass indicating a type `M` is finitely generated as a
 group.
 
 -/
@@ -44,26 +44,26 @@ section Submonoid
 
 /-- A submonoid of `M` is finitely generated if it is the closure of a finite subset of `M`. -/
 @[to_additive]
-def Submonoid.Fg (P : Submonoid M) : Prop :=
+def Submonoid.FG (P : Submonoid M) : Prop :=
   ∃ S : Finset M, Submonoid.closure ↑S = P
-#align submonoid.fg Submonoid.Fg
-#align add_submonoid.fg AddSubmonoid.Fg
+#align submonoid.fg Submonoid.FG
+#align add_submonoid.fg AddSubmonoid.FG
 
 /-- An additive submonoid of `N` is finitely generated if it is the closure of a finite subset of
 `M`. -/
-add_decl_doc AddSubmonoid.Fg
+add_decl_doc AddSubmonoid.FG
 
-/-- An equivalent expression of `Submonoid.Fg` in terms of `Set.Finite` instead of `Finset`. -/
-@[to_additive "An equivalent expression of `AddSubmonoid.Fg` in terms of `Set.Finite` instead of
+/-- An equivalent expression of `Submonoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
+@[to_additive "An equivalent expression of `AddSubmonoid.FG` in terms of `Set.Finite` instead of
 `Finset`."]
 theorem Submonoid.fg_iff (P : Submonoid M) :
-    Submonoid.Fg P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite :=
+    Submonoid.FG P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite :=
   ⟨fun ⟨S, hS⟩ => ⟨S, hS, Finset.finite_toSet S⟩, fun ⟨S, hS, hf⟩ =>
     ⟨Set.Finite.toFinset hf, by simp [hS]⟩⟩
 #align submonoid.fg_iff Submonoid.fg_iff
 #align add_submonoid.fg_iff AddSubmonoid.fg_iff
 
-theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.Fg ↔ P.toAddSubmonoid.Fg :=
+theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.FG ↔ P.toAddSubmonoid.FG :=
   ⟨fun h =>
     let ⟨S, hS, hf⟩ := (Submonoid.fg_iff _).1 h
     (AddSubmonoid.fg_iff _).mpr
@@ -74,7 +74,7 @@ theorem Submonoid.fg_iff_add_fg (P : Submonoid M) : P.Fg ↔ P.toAddSubmonoid.Fg
       ⟨Multiplicative.ofAdd ⁻¹' T, by simp [← AddSubmonoid.toSubmonoid'_closure, hT], hf⟩⟩
 #align submonoid.fg_iff_add_fg Submonoid.fg_iff_add_fg
 
-theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.Fg ↔ P.toSubmonoid.Fg := by
+theorem AddSubmonoid.fg_iff_mul_fg (P : AddSubmonoid N) : P.FG ↔ P.toSubmonoid.FG := by
   convert (Submonoid.fg_iff_add_fg (toSubmonoid P)).symm
 #align add_submonoid.fg_iff_mul_fg AddSubmonoid.fg_iff_mul_fg
 
@@ -85,56 +85,56 @@ section Monoid
 variable (M N)
 
 /-- A monoid is finitely generated if it is finitely generated as a submonoid of itself. -/
-class Monoid.Fg : Prop where
-  out : (⊤ : Submonoid M).Fg
-#align monoid.fg Monoid.Fg
+class Monoid.FG : Prop where
+  out : (⊤ : Submonoid M).FG
+#align monoid.fg Monoid.FG
 
 /-- An additive monoid is finitely generated if it is finitely generated as an additive submonoid of
 itself. -/
-class AddMonoid.Fg : Prop where
-  out : (⊤ : AddSubmonoid N).Fg
-#align add_monoid.fg AddMonoid.Fg
+class AddMonoid.FG : Prop where
+  out : (⊤ : AddSubmonoid N).FG
+#align add_monoid.fg AddMonoid.FG
 
-attribute [to_additive] Monoid.Fg
+attribute [to_additive] Monoid.FG
 
 variable {M N}
 
-theorem Monoid.fg_def : Monoid.Fg M ↔ (⊤ : Submonoid M).Fg :=
+theorem Monoid.fg_def : Monoid.FG M ↔ (⊤ : Submonoid M).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align monoid.fg_def Monoid.fg_def
 
-theorem AddMonoid.fg_def : AddMonoid.Fg N ↔ (⊤ : AddSubmonoid N).Fg :=
+theorem AddMonoid.fg_def : AddMonoid.FG N ↔ (⊤ : AddSubmonoid N).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_monoid.fg_def AddMonoid.fg_def
 
-/-- An equivalent expression of `Monoid.Fg` in terms of `Set.Finite` instead of `Finset`. -/
+/-- An equivalent expression of `Monoid.FG` in terms of `Set.Finite` instead of `Finset`. -/
 @[to_additive
-      "An equivalent expression of `AddMonoid.Fg` in terms of `Set.Finite` instead of `Finset`."]
+      "An equivalent expression of `AddMonoid.FG` in terms of `Set.Finite` instead of `Finset`."]
 theorem Monoid.fg_iff :
-    Monoid.Fg M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite :=
+    Monoid.FG M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite :=
   ⟨fun h => (Submonoid.fg_iff ⊤).1 h.out, fun h => ⟨(Submonoid.fg_iff ⊤).2 h⟩⟩
 #align monoid.fg_iff Monoid.fg_iff
 #align add_monoid.fg_iff AddMonoid.fg_iff
 
-theorem Monoid.fg_iff_add_fg : Monoid.Fg M ↔ AddMonoid.Fg (Additive M) :=
+theorem Monoid.fg_iff_add_fg : Monoid.FG M ↔ AddMonoid.FG (Additive M) :=
   ⟨fun h => ⟨(Submonoid.fg_iff_add_fg ⊤).1 h.out⟩, fun h => ⟨(Submonoid.fg_iff_add_fg ⊤).2 h.out⟩⟩
 #align monoid.fg_iff_add_fg Monoid.fg_iff_add_fg
 
-theorem AddMonoid.fg_iff_mul_fg : AddMonoid.Fg N ↔ Monoid.Fg (Multiplicative N) :=
+theorem AddMonoid.fg_iff_mul_fg : AddMonoid.FG N ↔ Monoid.FG (Multiplicative N) :=
   ⟨fun h => ⟨(AddSubmonoid.fg_iff_mul_fg ⊤).1 h.out⟩, fun h =>
     ⟨(AddSubmonoid.fg_iff_mul_fg ⊤).2 h.out⟩⟩
 #align add_monoid.fg_iff_mul_fg AddMonoid.fg_iff_mul_fg
 
-instance AddMonoid.fg_of_monoid_fg [Monoid.Fg M] : AddMonoid.Fg (Additive M) :=
+instance AddMonoid.fg_of_monoid_fg [Monoid.FG M] : AddMonoid.FG (Additive M) :=
   Monoid.fg_iff_add_fg.1 ‹_›
 #align add_monoid.fg_of_monoid_fg AddMonoid.fg_of_monoid_fg
 
-instance Monoid.fg_of_addMonoid_fg [AddMonoid.Fg N] : Monoid.Fg (Multiplicative N) :=
+instance Monoid.fg_of_addMonoid_fg [AddMonoid.FG N] : Monoid.FG (Multiplicative N) :=
   AddMonoid.fg_iff_mul_fg.1 ‹_›
 #align monoid.fg_of_add_monoid_fg Monoid.fg_of_addMonoid_fg
 
 @[to_additive]
-instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.Fg M := by
+instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.FG M := by
   cases nonempty_fintype M
   exact ⟨⟨Finset.univ, by rw [Finset.coe_univ] ; exact Submonoid.closure_univ⟩⟩
 #align monoid.fg_of_finite Monoid.fg_of_finite
@@ -143,17 +143,17 @@ instance (priority := 100) Monoid.fg_of_finite [Finite M] : Monoid.Fg M := by
 end Monoid
 
 @[to_additive]
-theorem Submonoid.Fg.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.Fg) (e : M →* M') :
-    (P.map e).Fg := by
+theorem Submonoid.FG.map {M' : Type _} [Monoid M'] {P : Submonoid M} (h : P.FG) (e : M →* M') :
+    (P.map e).FG := by
   classical
     obtain ⟨s, rfl⟩ := h
     exact ⟨s.image e, by rw [Finset.coe_image, MonoidHom.map_mclosure]⟩
-#align submonoid.fg.map Submonoid.Fg.map
-#align add_submonoid.fg.map AddSubmonoid.Fg.map
+#align submonoid.fg.map Submonoid.FG.map
+#align add_submonoid.fg.map AddSubmonoid.FG.map
 
 @[to_additive]
-theorem Submonoid.Fg.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
-    (he : Function.Injective e) (h : (P.map e).Fg) : P.Fg := by
+theorem Submonoid.FG.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (e : M →* M')
+    (he : Function.Injective e) (h : (P.map e).FG) : P.FG := by
   obtain ⟨s, hs⟩ := h
   use s.preimage e (he.injOn _)
   apply Submonoid.map_injective_of_injective he
@@ -162,19 +162,19 @@ theorem Submonoid.Fg.map_injective {M' : Type _} [Monoid M'] {P : Submonoid M} (
   rw [Set.image_preimage_eq_iff, ← MonoidHom.coe_mrange e, ← Submonoid.closure_le, hs,
       MonoidHom.mrange_eq_map e]
   exact Submonoid.monotone_map le_top
-#align submonoid.fg.map_injective Submonoid.Fg.map_injective
-#align add_submonoid.fg.map_injective AddSubmonoid.Fg.map_injective
+#align submonoid.fg.map_injective Submonoid.FG.map_injective
+#align add_submonoid.fg.map_injective AddSubmonoid.FG.map_injective
 
 @[to_additive (attr := simp)]
-theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.Fg N ↔ N.Fg := by
+theorem Monoid.fg_iff_submonoid_fg (N : Submonoid M) : Monoid.FG N ↔ N.FG := by
   conv_rhs => rw [← N.range_subtype, MonoidHom.mrange_eq_map]
   exact ⟨fun h => h.out.map N.subtype, fun h => ⟨h.map_injective N.subtype Subtype.coe_injective⟩⟩
 #align monoid.fg_iff_submonoid_fg Monoid.fg_iff_submonoid_fg
 #align add_monoid.fg_iff_add_submonoid_fg AddMonoid.fg_iff_addSubmonoid_fg
 
 @[to_additive]
-theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M →* M')
-    (hf : Function.Surjective f) : Monoid.Fg M' := by
+theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M')
+    (hf : Function.Surjective f) : Monoid.FG M' := by
   classical
     obtain ⟨s, hs⟩ := Monoid.fg_def.mp ‹_›
     use s.image f
@@ -184,33 +184,33 @@ theorem Monoid.fg_of_surjective {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M 
 #align add_monoid.fg_of_surjective AddMonoid.fg_of_surjective
 
 @[to_additive]
-instance Monoid.fg_range {M' : Type _} [Monoid M'] [Monoid.Fg M] (f : M →* M') :
-    Monoid.Fg (MonoidHom.mrange f) :=
+instance Monoid.fg_range {M' : Type _} [Monoid M'] [Monoid.FG M] (f : M →* M') :
+    Monoid.FG (MonoidHom.mrange f) :=
   Monoid.fg_of_surjective f.mrangeRestrict f.mrangeRestrict_surjective
 #align monoid.fg_range Monoid.fg_range
 #align add_monoid.fg_range AddMonoid.fg_range
 
 @[to_additive AddSubmonoid.multiples_fg]
-theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).Fg :=
+theorem Submonoid.powers_fg (r : M) : (Submonoid.powers r).FG :=
   ⟨{r}, (Finset.coe_singleton r).symm ▸ (Submonoid.powers_eq_closure r).symm⟩
 #align submonoid.powers_fg Submonoid.powers_fg
 #align add_submonoid.multiples_fg AddSubmonoid.multiples_fg
 
 @[to_additive AddMonoid.multiples_fg]
-instance Monoid.powers_fg (r : M) : Monoid.Fg (Submonoid.powers r) :=
+instance Monoid.powers_fg (r : M) : Monoid.FG (Submonoid.powers r) :=
   (Monoid.fg_iff_submonoid_fg _).mpr (Submonoid.powers_fg r)
 #align monoid.powers_fg Monoid.powers_fg
 #align add_monoid.multiples_fg AddMonoid.multiples_fg
 
 @[to_additive]
-instance Monoid.closure_finset_fg (s : Finset M) : Monoid.Fg (Submonoid.closure (s : Set M)) := by
+instance Monoid.closure_finset_fg (s : Finset M) : Monoid.FG (Submonoid.closure (s : Set M)) := by
   refine' ⟨⟨s.preimage Subtype.val (Subtype.coe_injective.injOn _), _⟩⟩
   rw [Finset.coe_preimage, Submonoid.closure_closure_coe_preimage]
 #align monoid.closure_finset_fg Monoid.closure_finset_fg
 #align add_monoid.closure_finset_fg AddMonoid.closure_finset_fg
 
 @[to_additive]
-instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.Fg (Submonoid.closure s) :=
+instance Monoid.closure_finite_fg (s : Set M) [Finite s] : Monoid.FG (Submonoid.closure s) :=
   haveI := Fintype.ofFinite s
   s.coe_toFinset ▸ Monoid.closure_finset_fg s.toFinset
 #align monoid.closure_finite_fg Monoid.closure_finite_fg
@@ -225,20 +225,20 @@ section Subgroup
 
 /-- A subgroup of `G` is finitely generated if it is the closure of a finite subset of `G`. -/
 @[to_additive]
-def Subgroup.Fg (P : Subgroup G) : Prop :=
+def Subgroup.FG (P : Subgroup G) : Prop :=
   ∃ S : Finset G, Subgroup.closure ↑S = P
-#align subgroup.fg Subgroup.Fg
-#align add_subgroup.fg AddSubgroup.Fg
+#align subgroup.fg Subgroup.FG
+#align add_subgroup.fg AddSubgroup.FG
 
 /-- An additive subgroup of `H` is finitely generated if it is the closure of a finite subset of
 `H`. -/
-add_decl_doc AddSubgroup.Fg
+add_decl_doc AddSubgroup.FG
 
-/-- An equivalent expression of `Subgroup.Fg` in terms of `Set.Finite` instead of `Finset`. -/
+/-- An equivalent expression of `Subgroup.FG` in terms of `Set.Finite` instead of `Finset`. -/
 @[to_additive "An equivalent expression of `AddSubgroup.fg` in terms of `Set.Finite` instead of
 `Finset`."]
 theorem Subgroup.fg_iff (P : Subgroup G) :
-    Subgroup.Fg P ↔ ∃ S : Set G, Subgroup.closure S = P ∧ S.Finite :=
+    Subgroup.FG P ↔ ∃ S : Set G, Subgroup.closure S = P ∧ S.Finite :=
   ⟨fun ⟨S, hS⟩ => ⟨S, hS, Finset.finite_toSet S⟩, fun ⟨S, hS, hf⟩ =>
     ⟨Set.Finite.toFinset hf, by simp [hS]⟩⟩
 #align subgroup.fg_iff Subgroup.fg_iff
@@ -247,7 +247,7 @@ theorem Subgroup.fg_iff (P : Subgroup G) :
 /-- A subgroup is finitely generated if and only if it is finitely generated as a submonoid. -/
 @[to_additive "An additive subgroup is finitely generated if
 and only if it is finitely generated as an additive submonoid."]
-theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.Fg ↔ P.toSubmonoid.Fg := by
+theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.FG ↔ P.toSubmonoid.FG := by
   constructor
   · rintro ⟨S, rfl⟩
     rw [Submonoid.fg_iff]
@@ -262,12 +262,12 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.Fg ↔ P.toSubmonoid.F
 #align subgroup.fg_iff_submonoid_fg Subgroup.fg_iff_submonoid_fg
 #align add_subgroup.fg_iff_add_submonoid.fg AddSubgroup.fg_iff_addSubmonoid_fg
 
-theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.Fg ↔ P.toAddSubgroup.Fg := by
+theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.FG ↔ P.toAddSubgroup.FG := by
   rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.fg_iff_addSubmonoid_fg]
   exact (Subgroup.toSubmonoid P).fg_iff_add_fg
 #align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fg
 
-theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.Fg ↔ P.toSubgroup.Fg := by
+theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.FG ↔ P.toSubgroup.FG := by
   rw [AddSubgroup.fg_iff_addSubmonoid_fg, Subgroup.fg_iff_submonoid_fg]
   exact AddSubmonoid.fg_iff_mul_fg (AddSubgroup.toAddSubmonoid P)
 #align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fg
@@ -279,39 +279,39 @@ section Group
 variable (G H)
 
 /-- A group is finitely generated if it is finitely generated as a submonoid of itself. -/
-class Group.Fg : Prop where
-  out : (⊤ : Subgroup G).Fg
-#align group.fg Group.Fg
+class Group.FG : Prop where
+  out : (⊤ : Subgroup G).FG
+#align group.fg Group.FG
 
 /-- An additive group is finitely generated if it is finitely generated as an additive submonoid of
 itself. -/
-class AddGroup.Fg : Prop where
-  out : (⊤ : AddSubgroup H).Fg
-#align add_group.fg AddGroup.Fg
+class AddGroup.FG : Prop where
+  out : (⊤ : AddSubgroup H).FG
+#align add_group.fg AddGroup.FG
 
-attribute [to_additive] Group.Fg
+attribute [to_additive] Group.FG
 
 variable {G H}
 
-theorem Group.fg_def : Group.Fg G ↔ (⊤ : Subgroup G).Fg :=
+theorem Group.fg_def : Group.FG G ↔ (⊤ : Subgroup G).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align group.fg_def Group.fg_def
 
-theorem AddGroup.fg_def : AddGroup.Fg H ↔ (⊤ : AddSubgroup H).Fg :=
+theorem AddGroup.fg_def : AddGroup.FG H ↔ (⊤ : AddSubgroup H).FG :=
   ⟨fun h => h.1, fun h => ⟨h⟩⟩
 #align add_group.fg_def AddGroup.fg_def
 
-/-- An equivalent expression of `Group.Fg` in terms of `Set.Finite` instead of `Finset`. -/
+/-- An equivalent expression of `Group.FG` in terms of `Set.Finite` instead of `Finset`. -/
 @[to_additive
       "An equivalent expression of `AddGroup.fg` in terms of `Set.Finite` instead of `Finset`."]
-theorem Group.fg_iff : Group.Fg G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ : Subgroup G) ∧ S.Finite :=
+theorem Group.fg_iff : Group.FG G ↔ ∃ S : Set G, Subgroup.closure S = (⊤ : Subgroup G) ∧ S.Finite :=
   ⟨fun h => (Subgroup.fg_iff ⊤).1 h.out, fun h => ⟨(Subgroup.fg_iff ⊤).2 h⟩⟩
 #align group.fg_iff Group.fg_iff
 #align add_group.fg_iff AddGroup.fg_iff
 
 @[to_additive]
 theorem Group.fg_iff' :
-    Group.Fg G ↔ ∃ (n : _)(S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
+    Group.FG G ↔ ∃ (n : _)(S : Finset G), S.card = n ∧ Subgroup.closure (S : Set G) = ⊤ :=
   Group.fg_def.trans ⟨fun ⟨S, hS⟩ => ⟨S.card, S, rfl, hS⟩, fun ⟨_n, S, _hn, hS⟩ => ⟨S, hS⟩⟩
 #align group.fg_iff' Group.fg_iff'
 #align add_group.fg_iff' AddGroup.fg_iff'
@@ -319,59 +319,59 @@ theorem Group.fg_iff' :
 /-- A group is finitely generated if and only if it is finitely generated as a monoid. -/
 @[to_additive "An additive group is finitely generated if and only
 if it is finitely generated as an additive monoid."]
-theorem Group.fg_iff_monoid_fg : Group.Fg G ↔ Monoid.Fg G :=
+theorem Group.fg_iff_monoid_fg : Group.FG G ↔ Monoid.FG G :=
   ⟨fun h => Monoid.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).1 (Group.fg_def.1 h), fun h =>
     Group.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).2 (Monoid.fg_def.1 h)⟩
 #align group.fg_iff_monoid.fg Group.fg_iff_monoid_fg
 #align add_group.fg_iff_add_monoid.fg AddGroup.fg_iff_addMonoid_fg
 
-theorem GroupFg.iff_add_fg : Group.Fg G ↔ AddGroup.Fg (Additive G) :=
+theorem GroupFG.iff_add_fg : Group.FG G ↔ AddGroup.FG (Additive G) :=
   ⟨fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).1 h.out⟩, fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).2 h.out⟩⟩
-#align group_fg.iff_add_fg GroupFg.iff_add_fg
+#align group_fg.iff_add_fg GroupFG.iff_add_fg
 
-theorem AddGroup.fg_iff_mul_fg : AddGroup.Fg H ↔ Group.Fg (Multiplicative H) :=
+theorem AddGroup.fg_iff_mul_fg : AddGroup.FG H ↔ Group.FG (Multiplicative H) :=
   ⟨fun h => ⟨(AddSubgroup.fg_iff_mul_fg ⊤).1 h.out⟩, fun h =>
     ⟨(AddSubgroup.fg_iff_mul_fg ⊤).2 h.out⟩⟩
 #align add_group.fg_iff_mul_fg AddGroup.fg_iff_mul_fg
 
-instance AddGroup.fg_of_group_fg [Group.Fg G] : AddGroup.Fg (Additive G) :=
-  GroupFg.iff_add_fg.1 ‹_›
+instance AddGroup.fg_of_group_fg [Group.FG G] : AddGroup.FG (Additive G) :=
+  GroupFG.iff_add_fg.1 ‹_›
 #align add_group.fg_of_group_fg AddGroup.fg_of_group_fg
 
-instance Group.fg_of_mul_group_fg [AddGroup.Fg H] : Group.Fg (Multiplicative H) :=
+instance Group.fg_of_mul_group_fg [AddGroup.FG H] : Group.FG (Multiplicative H) :=
   AddGroup.fg_iff_mul_fg.1 ‹_›
 #align group.fg_of_mul_group_fg Group.fg_of_mul_group_fg
 
 @[to_additive]
-instance (priority := 100) Group.fg_of_finite [Finite G] : Group.Fg G := by
+instance (priority := 100) Group.fg_of_finite [Finite G] : Group.FG G := by
   cases nonempty_fintype G
   exact ⟨⟨Finset.univ, by rw [Finset.coe_univ] ; exact Subgroup.closure_univ⟩⟩
 #align group.fg_of_finite Group.fg_of_finite
 #align add_group.fg_of_finite AddGroup.fg_of_finite
 
 @[to_additive]
-theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.Fg G] {f : G →* G'}
-    (hf : Function.Surjective f) : Group.Fg G' :=
+theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.FG G] {f : G →* G'}
+    (hf : Function.Surjective f) : Group.FG G' :=
   Group.fg_iff_monoid_fg.mpr <|
     @Monoid.fg_of_surjective G _ G' _ (Group.fg_iff_monoid_fg.mp hG) f hf
 #align group.fg_of_surjective Group.fg_of_surjective
 #align add_group.fg_of_surjective AddGroup.fg_of_surjective
 
 @[to_additive]
-instance Group.fg_range {G' : Type _} [Group G'] [Group.Fg G] (f : G →* G') : Group.Fg f.range :=
+instance Group.fg_range {G' : Type _} [Group G'] [Group.FG G] (f : G →* G') : Group.FG f.range :=
   Group.fg_of_surjective f.rangeRestrict_surjective
 #align group.fg_range Group.fg_range
 #align add_group.fg_range AddGroup.fg_range
 
 @[to_additive]
-instance Group.closure_finset_fg (s : Finset G) : Group.Fg (Subgroup.closure (s : Set G)) := by
+instance Group.closure_finset_fg (s : Finset G) : Group.FG (Subgroup.closure (s : Set G)) := by
   refine' ⟨⟨s.preimage Subtype.val (Subtype.coe_injective.injOn _), _⟩⟩
   rw [Finset.coe_preimage, ← Subgroup.coeSubtype, Subgroup.closure_preimage_eq_top]
 #align group.closure_finset_fg Group.closure_finset_fg
 #align add_group.closure_finset_fg AddGroup.closure_finset_fg
 
 @[to_additive]
-instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.Fg (Subgroup.closure s) :=
+instance Group.closure_finite_fg (s : Set G) [Finite s] : Group.FG (Subgroup.closure s) :=
   haveI := Fintype.ofFinite s
   s.coe_toFinset ▸ Group.closure_finset_fg s.toFinset
 #align group.closure_finite_fg Group.closure_finite_fg
@@ -381,20 +381,20 @@ variable (G)
 
 /-- The minimum number of generators of a group. -/
 @[to_additive "The minimum number of generators of an additive group"]
-noncomputable def Group.rank [h : Group.Fg G] :=
+noncomputable def Group.rank [h : Group.FG G] :=
   @Nat.find _ (Classical.decPred _) (Group.fg_iff'.mp h)
 #align group.rank Group.rank
 #align add_group.rank AddGroup.rank
 
 @[to_additive]
-theorem Group.rank_spec [h : Group.Fg G] :
+theorem Group.rank_spec [h : Group.FG G] :
     ∃ S : Finset G, S.card = Group.rank G ∧ Subgroup.closure (S : Set G) = ⊤ :=
   @Nat.find_spec _ (Classical.decPred _) (Group.fg_iff'.mp h)
 #align group.rank_spec Group.rank_spec
 #align add_group.rank_spec AddGroup.rank_spec
 
 @[to_additive]
-theorem Group.rank_le [h : Group.Fg G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
+theorem Group.rank_le [h : Group.FG G] {S : Finset G} (hS : Subgroup.closure (S : Set G) = ⊤) :
     Group.rank G ≤ S.card :=
   @Nat.find_le _ _ (Classical.decPred _) (Group.fg_iff'.mp h) ⟨S, rfl, hS⟩
 #align group.rank_le Group.rank_le
@@ -403,7 +403,7 @@ theorem Group.rank_le [h : Group.Fg G] {S : Finset G} (hS : Subgroup.closure (S
 variable {G} {G' : Type _} [Group G']
 
 @[to_additive]
-theorem Group.rank_le_of_surjective [Group.Fg G] [Group.Fg G'] (f : G →* G')
+theorem Group.rank_le_of_surjective [Group.FG G] [Group.FG G'] (f : G →* G')
     (hf : Function.Surjective f) : Group.rank G' ≤ Group.rank G := by
   classical
     obtain ⟨S, hS1, hS2⟩ := Group.rank_spec G
@@ -415,13 +415,13 @@ theorem Group.rank_le_of_surjective [Group.Fg G] [Group.Fg G'] (f : G →* G')
 #align add_group.rank_le_of_surjective AddGroup.rank_le_of_surjective
 
 @[to_additive]
-theorem Group.rank_range_le [Group.Fg G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G :=
+theorem Group.rank_range_le [Group.FG G] {f : G →* G'} : Group.rank f.range ≤ Group.rank G :=
   Group.rank_le_of_surjective f.rangeRestrict f.rangeRestrict_surjective
 #align group.rank_range_le Group.rank_range_le
 #align add_group.rank_range_le AddGroup.rank_range_le
 
 @[to_additive]
-theorem Group.rank_congr [Group.Fg G] [Group.Fg G'] (f : G ≃* G') : Group.rank G = Group.rank G' :=
+theorem Group.rank_congr [Group.FG G] [Group.FG G'] (f : G ≃* G') : Group.rank G = Group.rank G' :=
   le_antisymm (Group.rank_le_of_surjective f.symm f.symm.surjective)
     (Group.rank_le_of_surjective f f.surjective)
 #align group.rank_congr Group.rank_congr
@@ -432,7 +432,7 @@ end Group
 namespace Subgroup
 
 @[to_additive]
-theorem rank_congr {H K : Subgroup G} [Group.Fg H] [Group.Fg K] (h : H = K) :
+theorem rank_congr {H K : Subgroup G} [Group.FG H] [Group.FG K] (h : H = K) :
     Group.rank H = Group.rank K := by subst h; rfl
 #align subgroup.rank_congr Subgroup.rank_congr
 #align add_subgroup.rank_congr AddSubgroup.rank_congr
@@ -466,7 +466,7 @@ end Subgroup
 section QuotientGroup
 
 @[to_additive]
-instance QuotientGroup.fg [Group.Fg G] (N : Subgroup G) [Subgroup.Normal N] : Group.Fg <| G ⧸ N :=
+instance QuotientGroup.fg [Group.FG G] (N : Subgroup G) [Subgroup.Normal N] : Group.FG <| G ⧸ N :=
   Group.fg_of_surjective <| QuotientGroup.mk'_surjective N
 #align quotient_group.fg QuotientGroup.fg
 #align quotient_add_group.fg QuotientAddGroup.fg

@@ -26,7 +26,7 @@ finitely-generated modules.
 * `Submonoid.Fg S`, `AddSubmonoid.Fg S` : A submonoid `S` is finitely generated.
 * `Monoid.Fg M`, `AddMonoid.Fg M` : A typeclass indicating a type `M` is finitely generated as a
 monoid.
-* `Subgroup.Fg S`, `AddSubgroup.fg S` : A subgroup `S` is finitely generated.
+* `Subgroup.Fg S`, `AddSubgroup.Fg S` : A subgroup `S` is finitely generated.
 * `Group.Fg M`, `AddGroup.Fg M` : A typeclass indicating a type `M` is finitely generated as a
 group.
 
@@ -54,7 +54,7 @@ def Submonoid.Fg (P : Submonoid M) : Prop :=
 add_decl_doc AddSubmonoid.Fg
 
 /-- An equivalent expression of `Submonoid.Fg` in terms of `Set.Finite` instead of `Finset`. -/
-@[to_additive "An equivalent expression of `AddSubmonoid.fg` in terms of `Set.Finite` instead of
+@[to_additive "An equivalent expression of `AddSubmonoid.Fg` in terms of `Set.Finite` instead of
 `Finset`."]
 theorem Submonoid.fg_iff (P : Submonoid M) :
     Submonoid.Fg P ↔ ∃ S : Set M, Submonoid.closure S = P ∧ S.Finite :=
@@ -109,7 +109,7 @@ theorem AddMonoid.fg_def : AddMonoid.Fg N ↔ (⊤ : AddSubmonoid N).Fg :=
 
 /-- An equivalent expression of `Monoid.Fg` in terms of `Set.Finite` instead of `Finset`. -/
 @[to_additive
-      "An equivalent expression of `AddMonoid.fg` in terms of `Set.Finite` instead of `Finset`."]
+      "An equivalent expression of `AddMonoid.Fg` in terms of `Set.Finite` instead of `Finset`."]
 theorem Monoid.fg_iff :
     Monoid.Fg M ↔ ∃ S : Set M, Submonoid.closure S = (⊤ : Submonoid M) ∧ S.Finite :=
   ⟨fun h => (Submonoid.fg_iff ⊤).1 h.out, fun h => ⟨(Submonoid.fg_iff ⊤).2 h⟩⟩
@@ -245,7 +245,7 @@ theorem Subgroup.fg_iff (P : Subgroup G) :
 #align add_subgroup.fg_iff AddSubgroup.fg_iff
 
 /-- A subgroup is finitely generated if and only if it is finitely generated as a submonoid. -/
-@[to_additive AddSubgroup.FgIffAddSubmonoid.fg "An additive subgroup is finitely generated if
+@[to_additive "An additive subgroup is finitely generated if
 and only if it is finitely generated as an additive submonoid."]
 theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.Fg ↔ P.toSubmonoid.Fg := by
   constructor
@@ -260,15 +260,15 @@ theorem Subgroup.fg_iff_submonoid_fg (P : Subgroup G) : P.Fg ↔ P.toSubmonoid.F
     · rw [← Subgroup.toSubmonoid_le, ← hS, Submonoid.closure_le]
       exact Subgroup.subset_closure
 #align subgroup.fg_iff_submonoid_fg Subgroup.fg_iff_submonoid_fg
-#align add_subgroup.fg_iff_add_submonoid.fg AddSubgroup.FgIffAddSubmonoid.fg
+#align add_subgroup.fg_iff_add_submonoid.fg AddSubgroup.fg_iff_addSubmonoid_fg
 
 theorem Subgroup.fg_iff_add_fg (P : Subgroup G) : P.Fg ↔ P.toAddSubgroup.Fg := by
-  rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.FgIffAddSubmonoid.fg]
+  rw [Subgroup.fg_iff_submonoid_fg, AddSubgroup.fg_iff_addSubmonoid_fg]
   exact (Subgroup.toSubmonoid P).fg_iff_add_fg
 #align subgroup.fg_iff_add_fg Subgroup.fg_iff_add_fg
 
 theorem AddSubgroup.fg_iff_mul_fg (P : AddSubgroup H) : P.Fg ↔ P.toSubgroup.Fg := by
-  rw [AddSubgroup.FgIffAddSubmonoid.fg, Subgroup.fg_iff_submonoid_fg]
+  rw [AddSubgroup.fg_iff_addSubmonoid_fg, Subgroup.fg_iff_submonoid_fg]
   exact AddSubmonoid.fg_iff_mul_fg (AddSubgroup.toAddSubmonoid P)
 #align add_subgroup.fg_iff_mul_fg AddSubgroup.fg_iff_mul_fg
 
@@ -317,13 +317,13 @@ theorem Group.fg_iff' :
 #align add_group.fg_iff' AddGroup.fg_iff'
 
 /-- A group is finitely generated if and only if it is finitely generated as a monoid. -/
-@[to_additive AddGroup.FgIffAddMonoid.fg "An additive group is finitely generated if and only
+@[to_additive "An additive group is finitely generated if and only
 if it is finitely generated as an additive monoid."]
-theorem Group.FgIffMonoid.fg : Group.Fg G ↔ Monoid.Fg G :=
+theorem Group.fg_iff_monoid_fg : Group.Fg G ↔ Monoid.Fg G :=
   ⟨fun h => Monoid.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).1 (Group.fg_def.1 h), fun h =>
     Group.fg_def.2 <| (Subgroup.fg_iff_submonoid_fg ⊤).2 (Monoid.fg_def.1 h)⟩
-#align group.fg_iff_monoid.fg Group.FgIffMonoid.fg
-#align add_group.fg_iff_add_monoid.fg AddGroup.FgIffAddMonoid.fg
+#align group.fg_iff_monoid.fg Group.fg_iff_monoid_fg
+#align add_group.fg_iff_add_monoid.fg AddGroup.fg_iff_addMonoid_fg
 
 theorem GroupFg.iff_add_fg : Group.Fg G ↔ AddGroup.Fg (Additive G) :=
   ⟨fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).1 h.out⟩, fun h => ⟨(Subgroup.fg_iff_add_fg ⊤).2 h.out⟩⟩
@@ -352,7 +352,8 @@ instance (priority := 100) Group.fg_of_finite [Finite G] : Group.Fg G := by
 @[to_additive]
 theorem Group.fg_of_surjective {G' : Type _} [Group G'] [hG : Group.Fg G] {f : G →* G'}
     (hf : Function.Surjective f) : Group.Fg G' :=
-  Group.FgIffMonoid.fg.mpr <| @Monoid.fg_of_surjective G _ G' _ (Group.FgIffMonoid.fg.mp hG) f hf
+  Group.fg_iff_monoid_fg.mpr <|
+    @Monoid.fg_of_surjective G _ G' _ (Group.fg_iff_monoid_fg.mp hG) f hf
 #align group.fg_of_surjective Group.fg_of_surjective
 #align add_group.fg_of_surjective AddGroup.fg_of_surjective
 
@@ -440,8 +441,7 @@ theorem rank_congr {H K : Subgroup G} [Group.Fg H] [Group.Fg K] (h : H = K) :
 theorem rank_closure_finset_le_card (s : Finset G) : Group.rank (closure (s : Set G)) ≤ s.card := by
   classical
     let t : Finset (closure (s : Set G)) := s.preimage Subtype.val (Subtype.coe_injective.injOn _)
-    have ht : closure (t : Set (closure (s : Set G))) = ⊤ :=
-      by
+    have ht : closure (t : Set (closure (s : Set G))) = ⊤ := by
       rw [Finset.coe_preimage]
       exact closure_preimage_eq_top (s : Set G)
     apply (Group.rank_le (closure (s : Set G)) ht).trans

Co-authored-by: Johan Commelin <johan@commelin.net>