group_theory.submonoid.membership ⟷ Mathlib.GroupTheory.Submonoid.Membership

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

@@ -614,7 +614,7 @@ theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (
 #align submonoid.map_powers Submonoid.map_powers
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:642:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 #print Submonoid.closureCommMonoidOfComm /-
 /-- If all the elements of a set `s` commute, then `closure s` is a commutative monoid. -/
 @[to_additive

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

@@ -314,7 +314,7 @@ then it holds for all elements of the supremum of `S`. -/
 theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
     (hp : ∀ (i), ∀ x ∈ S i, C x) (h1 : C 1) (hmul : ∀ x y, C x → C y → C (x * y)) : C x :=
   by
-  rw [supr_eq_closure] at hx 
+  rw [supr_eq_closure] at hx
   refine' closure_induction hx (fun x hx => _) h1 hmul
   obtain ⟨i, hi⟩ := set.mem_Union.mp hx
   exact hp _ _ hi
@@ -428,7 +428,7 @@ theorem closure_eq_image_prod (s : Set M) :
 @[to_additive]
 theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
     ∃ (l : List M) (hl : ∀ y ∈ l, y ∈ s), l.Prod = x := by
-  rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image_iff_bex] at hx 
+  rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image_iff_bex] at hx
 #align submonoid.exists_list_of_mem_closure Submonoid.exists_list_of_mem_closure
 #align add_submonoid.exists_list_of_mem_closure AddSubmonoid.exists_list_of_mem_closure
 -/
@@ -439,7 +439,7 @@ theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {
     (hx : x ∈ closure s) : ∃ (l : Multiset M) (hl : ∀ y ∈ l, y ∈ s), l.Prod = x :=
   by
   obtain ⟨l, h1, h2⟩ := exists_list_of_mem_closure hx
-  exact ⟨l, h1, (Multiset.coe_prod l).trans h2⟩
+  exact ⟨l, h1, (Multiset.prod_coe l).trans h2⟩
 #align submonoid.exists_multiset_of_mem_closure Submonoid.exists_multiset_of_mem_closure
 #align add_submonoid.exists_multiset_of_mem_closure AddSubmonoid.exists_multiset_of_mem_closure
 -/
@@ -449,7 +449,7 @@ theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {
 theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
     (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
   by
-  rw [closure_eq_mrange] at h 
+  rw [closure_eq_mrange] at h
   obtain ⟨l, rfl⟩ := h
   induction' l using FreeMonoid.recOn with x y ih
   · exact H1

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

@@ -522,17 +522,17 @@ theorem powers_eq_closure (n : M) : powers n = closure {n} := by ext;
 #align submonoid.powers_eq_closure Submonoid.powers_eq_closure
 -/
 
-#print Submonoid.powers_subset /-
-theorem powers_subset {n : M} {P : Submonoid M} (h : n ∈ P) : powers n ≤ P := fun x hx =>
+#print Submonoid.powers_le /-
+theorem powers_le {n : M} {P : Submonoid M} (h : n ∈ P) : powers n ≤ P := fun x hx =>
   match x, hx with
   | _, ⟨i, rfl⟩ => pow_mem h i
-#align submonoid.powers_subset Submonoid.powers_subset
+#align submonoid.powers_subset Submonoid.powers_le
 -/
 
 #print Submonoid.powers_one /-
 @[simp]
 theorem powers_one : powers (1 : M) = ⊥ :=
-  bot_unique <| powers_subset (one_mem _)
+  bot_unique <| powers_le (one_mem _)
 #align submonoid.powers_one Submonoid.powers_one
 -/
 
@@ -731,7 +731,7 @@ attribute [to_additive mem_multiples_iff] Submonoid.mem_powers_iff
 
 attribute [to_additive multiples_eq_closure] Submonoid.powers_eq_closure
 
-attribute [to_additive multiples_subset] Submonoid.powers_subset
+attribute [to_additive multiples_subset] Submonoid.powers_le
 
 attribute [to_additive multiples_zero] Submonoid.powers_one
 

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

@@ -223,7 +223,7 @@ theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (
   by
   refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_iSup S i) hi⟩
   suffices x ∈ closure (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
-    simpa only [closure_Union_of_finite, closure_eq (S _)] using this
+    simpa only [closure_iUnion_of_finite, closure_eq (S _)] using this
   refine' fun hx => closure_induction hx (fun _ => mem_Union.1) _ _
   · exact hι.elim fun i => ⟨i, (S i).one_mem⟩
   · rintro x y ⟨i, hi⟩ ⟨j, hj⟩

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

@@ -4,10 +4,10 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzzard,
 Amelia Livingston, Yury Kudryashov
 -/
-import Mathbin.GroupTheory.Submonoid.Operations
-import Mathbin.Algebra.BigOperators.Basic
-import Mathbin.Algebra.FreeMonoid.Basic
-import Mathbin.Data.Finset.NoncommProd
+import GroupTheory.Submonoid.Operations
+import Algebra.BigOperators.Basic
+import Algebra.FreeMonoid.Basic
+import Data.Finset.NoncommProd
 
 #align_import group_theory.submonoid.membership from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
 
@@ -614,7 +614,7 @@ theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (
 #align submonoid.map_powers Submonoid.map_powers
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:641:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 #print Submonoid.closureCommMonoidOfComm /-
 /-- If all the elements of a set `s` commute, then `closure s` is a commutative monoid. -/
 @[to_additive

mathlib commit https://github.com/leanprover-community/mathlib/commit/442a83d738cb208d3600056c489be16900ba701d

@@ -223,7 +223,7 @@ theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (
   by
   refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_iSup S i) hi⟩
   suffices x ∈ closure (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
-    simpa only [closure_iUnion, closure_eq (S _)] using this
+    simpa only [closure_Union_of_finite, closure_eq (S _)] using this
   refine' fun hx => closure_induction hx (fun _ => mem_Union.1) _ _
   · exact hι.elim fun i => ⟨i, (S i).one_mem⟩
   · rintro x y ⟨i, hi⟩ ⟨j, hj⟩

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

@@ -228,7 +228,7 @@ theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (
   · exact hι.elim fun i => ⟨i, (S i).one_mem⟩
   · rintro x y ⟨i, hi⟩ ⟨j, hj⟩
     rcases hS i j with ⟨k, hki, hkj⟩
-    exact ⟨k, (S k).mul_mem (hki hi) (hkj hj)⟩
+    exact ⟨k, (S k).hMul_mem (hki hi) (hkj hj)⟩
 #align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directed
 #align add_submonoid.mem_supr_of_directed AddSubmonoid.mem_iSup_of_directed
 -/
@@ -281,7 +281,7 @@ theorem mem_sup_right {S T : Submonoid M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔
 #print Submonoid.mul_mem_sup /-
 @[to_additive]
 theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T :=
-  (S ⊔ T).mul_mem (mem_sup_left hx) (mem_sup_right hy)
+  (S ⊔ T).hMul_mem (mem_sup_left hx) (mem_sup_right hy)
 #align submonoid.mul_mem_sup Submonoid.mul_mem_sup
 #align add_submonoid.add_mem_sup AddSubmonoid.add_mem_sup
 -/
@@ -327,7 +327,7 @@ theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {
 @[elab_as_elim, to_additive "A dependent version of `add_submonoid.supr_induction`. "]
 theorem iSup_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
     (hp : ∀ (i), ∀ x ∈ S i, C x (mem_iSup_of_mem i ‹_›)) (h1 : C 1 (one_mem _))
-    (hmul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (mul_mem ‹_› ‹_›)) {x : M}
+    (hmul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (hMul_mem ‹_› ‹_›)) {x : M}
     (hx : x ∈ ⨆ i, S i) : C x hx :=
   by
   refine' Exists.elim _ fun (hx : x ∈ ⨆ i, S i) (hc : C x hx) => hc
@@ -355,7 +355,7 @@ open Submonoid
 theorem closure_range_of : closure (Set.range <| @of α) = ⊤ :=
   eq_top_iff.2 fun x hx =>
     FreeMonoid.recOn x (one_mem _) fun x xs hxs =>
-      mul_mem (subset_closure <| Set.mem_range_self _) hxs
+      hMul_mem (subset_closure <| Set.mem_range_self _) hxs
 #align free_monoid.closure_range_of FreeMonoid.closure_range_of
 #align free_add_monoid.closure_range_of FreeAddMonoid.closure_range_of
 -/
@@ -472,7 +472,8 @@ theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : clos
 theorem closure_induction_right {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
     (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
   @closure_induction_left _ _ (MulOpposite.unop ⁻¹' s) (p ∘ MulOpposite.unop) (MulOpposite.op x)
-    (closure_induction h (fun x hx => subset_closure hx) (one_mem _) fun x y hx hy => mul_mem hy hx)
+    (closure_induction h (fun x hx => subset_closure hx) (one_mem _) fun x y hx hy =>
+      hMul_mem hy hx)
     H1 fun x hx y => Hmul _ _ hx
 #align submonoid.closure_induction_right Submonoid.closure_induction_right
 #align add_submonoid.closure_induction_right AddSubmonoid.closure_induction_right
@@ -595,7 +596,7 @@ def powLogEquiv [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n
 #print Submonoid.log_mul /-
 theorem log_mul [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)
     (x y : powers (n : M)) : log (x * y) = log x + log y :=
-  (powLogEquiv h).symm.map_mul x y
+  (powLogEquiv h).symm.map_hMul x y
 #align submonoid.log_mul Submonoid.log_mul
 -/
 

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

@@ -51,7 +51,7 @@ namespace SubmonoidClass
 #print SubmonoidClass.coe_list_prod /-
 @[simp, norm_cast, to_additive]
 theorem coe_list_prod (l : List S) : (l.Prod : M) = (l.map coe).Prod :=
-  (SubmonoidClass.Subtype S : _ →* M).map_list_prod l
+  (SubmonoidClass.subtype S : _ →* M).map_list_prod l
 #align submonoid_class.coe_list_prod SubmonoidClass.coe_list_prod
 #align add_submonoid_class.coe_list_sum AddSubmonoidClass.coe_list_sum
 -/
@@ -60,7 +60,7 @@ theorem coe_list_prod (l : List S) : (l.Prod : M) = (l.map coe).Prod :=
 @[simp, norm_cast, to_additive]
 theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (m : Multiset S) :
     (m.Prod : M) = (m.map coe).Prod :=
-  (SubmonoidClass.Subtype S : _ →* M).map_multiset_prod m
+  (SubmonoidClass.subtype S : _ →* M).map_multiset_prod m
 #align submonoid_class.coe_multiset_prod SubmonoidClass.coe_multiset_prod
 #align add_submonoid_class.coe_multiset_sum AddSubmonoidClass.coe_multiset_sum
 -/
@@ -69,7 +69,7 @@ theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 @[simp, norm_cast, to_additive]
 theorem coe_finset_prod {ι M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → S)
     (s : Finset ι) : ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
-  (SubmonoidClass.Subtype S : _ →* M).map_prod f s
+  (SubmonoidClass.subtype S : _ →* M).map_prod f s
 #align submonoid_class.coe_finset_prod SubmonoidClass.coe_finset_prod
 #align add_submonoid_class.coe_finset_sum AddSubmonoidClass.coe_finset_sum
 -/

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

@@ -3,17 +3,14 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzzard,
 Amelia Livingston, Yury Kudryashov
-
-! This file was ported from Lean 3 source module group_theory.submonoid.membership
-! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.GroupTheory.Submonoid.Operations
 import Mathbin.Algebra.BigOperators.Basic
 import Mathbin.Algebra.FreeMonoid.Basic
 import Mathbin.Data.Finset.NoncommProd
 
+#align_import group_theory.submonoid.membership from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
+
 /-!
 # Submonoids: membership criteria
 
@@ -616,7 +613,7 @@ theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (
 #align submonoid.map_powers Submonoid.map_powers
 -/
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 #print Submonoid.closureCommMonoidOfComm /-
 /-- If all the elements of a set `s` commute, then `closure s` is a commutative monoid. -/
 @[to_additive

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

@@ -51,11 +51,13 @@ variable [Monoid M] [SetLike B M] [SubmonoidClass B M] {S : B}
 
 namespace SubmonoidClass
 
+#print SubmonoidClass.coe_list_prod /-
 @[simp, norm_cast, to_additive]
 theorem coe_list_prod (l : List S) : (l.Prod : M) = (l.map coe).Prod :=
   (SubmonoidClass.Subtype S : _ →* M).map_list_prod l
 #align submonoid_class.coe_list_prod SubmonoidClass.coe_list_prod
 #align add_submonoid_class.coe_list_sum AddSubmonoidClass.coe_list_sum
+-/
 
 #print SubmonoidClass.coe_multiset_prod /-
 @[simp, norm_cast, to_additive]
@@ -66,23 +68,27 @@ theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 #align add_submonoid_class.coe_multiset_sum AddSubmonoidClass.coe_multiset_sum
 -/
 
+#print SubmonoidClass.coe_finset_prod /-
 @[simp, norm_cast, to_additive]
 theorem coe_finset_prod {ι M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → S)
     (s : Finset ι) : ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
   (SubmonoidClass.Subtype S : _ →* M).map_prod f s
 #align submonoid_class.coe_finset_prod SubmonoidClass.coe_finset_prod
 #align add_submonoid_class.coe_finset_sum AddSubmonoidClass.coe_finset_sum
+-/
 
 end SubmonoidClass
 
 open SubmonoidClass
 
+#print list_prod_mem /-
 /-- Product of a list of elements in a submonoid is in the submonoid. -/
 @[to_additive "Sum of a list of elements in an `add_submonoid` is in the `add_submonoid`."]
 theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ S) : l.Prod ∈ S := by
   lift l to List S using hl; rw [← coe_list_prod]; exact l.prod.coe_prop
 #align list_prod_mem list_prod_mem
 #align list_sum_mem list_sum_mem
+-/
 
 #print multiset_prod_mem /-
 /-- Product of a multiset of elements in a submonoid of a `comm_monoid` is in the submonoid. -/
@@ -95,6 +101,7 @@ theorem multiset_prod_mem {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 #align multiset_sum_mem multiset_sum_mem
 -/
 
+#print prod_mem /-
 /-- Product of elements of a submonoid of a `comm_monoid` indexed by a `finset` is in the
     submonoid. -/
 @[to_additive
@@ -106,38 +113,48 @@ theorem prod_mem {M : Type _} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
     hix ▸ h i hi
 #align prod_mem prod_mem
 #align sum_mem sum_mem
+-/
 
 namespace Submonoid
 
 variable (s : Submonoid M)
 
+#print Submonoid.coe_list_prod /-
 @[simp, norm_cast, to_additive]
 theorem coe_list_prod (l : List s) : (l.Prod : M) = (l.map coe).Prod :=
   s.Subtype.map_list_prod l
 #align submonoid.coe_list_prod Submonoid.coe_list_prod
 #align add_submonoid.coe_list_sum AddSubmonoid.coe_list_sum
+-/
 
+#print Submonoid.coe_multiset_prod /-
 @[simp, norm_cast, to_additive]
 theorem coe_multiset_prod {M} [CommMonoid M] (S : Submonoid M) (m : Multiset S) :
     (m.Prod : M) = (m.map coe).Prod :=
   S.Subtype.map_multiset_prod m
 #align submonoid.coe_multiset_prod Submonoid.coe_multiset_prod
 #align add_submonoid.coe_multiset_sum AddSubmonoid.coe_multiset_sum
+-/
 
+#print Submonoid.coe_finset_prod /-
 @[simp, norm_cast, to_additive]
 theorem coe_finset_prod {ι M} [CommMonoid M] (S : Submonoid M) (f : ι → S) (s : Finset ι) :
     ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
   S.Subtype.map_prod f s
 #align submonoid.coe_finset_prod Submonoid.coe_finset_prod
 #align add_submonoid.coe_finset_sum AddSubmonoid.coe_finset_sum
+-/
 
+#print Submonoid.list_prod_mem /-
 /-- Product of a list of elements in a submonoid is in the submonoid. -/
 @[to_additive "Sum of a list of elements in an `add_submonoid` is in the `add_submonoid`."]
 theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.Prod ∈ s := by
   lift l to List s using hl; rw [← coe_list_prod]; exact l.prod.coe_prop
 #align submonoid.list_prod_mem Submonoid.list_prod_mem
 #align add_submonoid.list_sum_mem AddSubmonoid.list_sum_mem
+-/
 
+#print Submonoid.multiset_prod_mem /-
 /-- Product of a multiset of elements in a submonoid of a `comm_monoid` is in the submonoid. -/
 @[to_additive
       "Sum of a multiset of elements in an `add_submonoid` of an `add_comm_monoid` is\nin the `add_submonoid`."]
@@ -146,7 +163,9 @@ theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
   rw [← coe_multiset_prod]; exact m.prod.coe_prop
 #align submonoid.multiset_prod_mem Submonoid.multiset_prod_mem
 #align add_submonoid.multiset_sum_mem AddSubmonoid.multiset_sum_mem
+-/
 
+#print Submonoid.multiset_noncommProd_mem /-
 @[to_additive]
 theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h : ∀ x ∈ m, x ∈ S) :
     m.noncommProd comm ∈ S :=
@@ -156,7 +175,9 @@ theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h :
   exact Submonoid.list_prod_mem _ h
 #align submonoid.multiset_noncomm_prod_mem Submonoid.multiset_noncommProd_mem
 #align add_submonoid.multiset_noncomm_sum_mem AddSubmonoid.multiset_noncommSum_mem
+-/
 
+#print Submonoid.prod_mem /-
 /-- Product of elements of a submonoid of a `comm_monoid` indexed by a `finset` is in the
     submonoid. -/
 @[to_additive
@@ -168,7 +189,9 @@ theorem prod_mem {M : Type _} [CommMonoid M] (S : Submonoid M) {ι : Type _} {t
     hix ▸ h i hi
 #align submonoid.prod_mem Submonoid.prod_mem
 #align add_submonoid.sum_mem AddSubmonoid.sum_mem
+-/
 
+#print Submonoid.noncommProd_mem /-
 @[to_additive]
 theorem noncommProd_mem (S : Submonoid M) {ι : Type _} (t : Finset ι) (f : ι → M) (comm)
     (h : ∀ c ∈ t, f c ∈ S) : t.noncommProd f comm ∈ S :=
@@ -180,6 +203,7 @@ theorem noncommProd_mem (S : Submonoid M) {ι : Type _} (t : Finset ι) (f : ι
   exact h x hx
 #align submonoid.noncomm_prod_mem Submonoid.noncommProd_mem
 #align add_submonoid.noncomm_sum_mem AddSubmonoid.noncommSum_mem
+-/
 
 end Submonoid
 
@@ -193,6 +217,7 @@ open Set
 
 namespace Submonoid
 
+#print Submonoid.mem_iSup_of_directed /-
 -- TODO: this section can be generalized to `[submonoid_class B M] [complete_lattice B]`
 -- such that `complete_lattice.le` coincides with `set_like.le`
 @[to_additive]
@@ -209,14 +234,18 @@ theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (
     exact ⟨k, (S k).mul_mem (hki hi) (hkj hj)⟩
 #align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directed
 #align add_submonoid.mem_supr_of_directed AddSubmonoid.mem_iSup_of_directed
+-/
 
+#print Submonoid.coe_iSup_of_directed /-
 @[to_additive]
 theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S) :
     ((⨆ i, S i : Submonoid M) : Set M) = ⋃ i, ↑(S i) :=
   Set.ext fun x => by simp [mem_supr_of_directed hS]
 #align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directed
 #align add_submonoid.coe_supr_of_directed AddSubmonoid.coe_iSup_of_directed
+-/
 
+#print Submonoid.mem_sSup_of_directedOn /-
 @[to_additive]
 theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
     (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s :=
@@ -225,46 +254,60 @@ theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
   simp only [sSup_eq_iSup', mem_supr_of_directed hS.directed_coe, SetCoe.exists, Subtype.coe_mk]
 #align submonoid.mem_Sup_of_directed_on Submonoid.mem_sSup_of_directedOn
 #align add_submonoid.mem_Sup_of_directed_on AddSubmonoid.mem_sSup_of_directedOn
+-/
 
+#print Submonoid.coe_sSup_of_directedOn /-
 @[to_additive]
 theorem coe_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
     (hS : DirectedOn (· ≤ ·) S) : (↑(sSup S) : Set M) = ⋃ s ∈ S, ↑s :=
   Set.ext fun x => by simp [mem_Sup_of_directed_on Sne hS]
 #align submonoid.coe_Sup_of_directed_on Submonoid.coe_sSup_of_directedOn
 #align add_submonoid.coe_Sup_of_directed_on AddSubmonoid.coe_sSup_of_directedOn
+-/
 
+#print Submonoid.mem_sup_left /-
 @[to_additive]
 theorem mem_sup_left {S T : Submonoid M} : ∀ {x : M}, x ∈ S → x ∈ S ⊔ T :=
   show S ≤ S ⊔ T from le_sup_left
 #align submonoid.mem_sup_left Submonoid.mem_sup_left
 #align add_submonoid.mem_sup_left AddSubmonoid.mem_sup_left
+-/
 
+#print Submonoid.mem_sup_right /-
 @[to_additive]
 theorem mem_sup_right {S T : Submonoid M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔ T :=
   show T ≤ S ⊔ T from le_sup_right
 #align submonoid.mem_sup_right Submonoid.mem_sup_right
 #align add_submonoid.mem_sup_right AddSubmonoid.mem_sup_right
+-/
 
+#print Submonoid.mul_mem_sup /-
 @[to_additive]
 theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T :=
   (S ⊔ T).mul_mem (mem_sup_left hx) (mem_sup_right hy)
 #align submonoid.mul_mem_sup Submonoid.mul_mem_sup
 #align add_submonoid.add_mem_sup AddSubmonoid.add_mem_sup
+-/
 
+#print Submonoid.mem_iSup_of_mem /-
 @[to_additive]
 theorem mem_iSup_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
     ∀ {x : M}, x ∈ S i → x ∈ iSup S :=
   show S i ≤ iSup S from le_iSup _ _
 #align submonoid.mem_supr_of_mem Submonoid.mem_iSup_of_mem
 #align add_submonoid.mem_supr_of_mem AddSubmonoid.mem_iSup_of_mem
+-/
 
+#print Submonoid.mem_sSup_of_mem /-
 @[to_additive]
 theorem mem_sSup_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
     ∀ {x : M}, x ∈ s → x ∈ sSup S :=
   show s ≤ sSup S from le_sSup hs
 #align submonoid.mem_Sup_of_mem Submonoid.mem_sSup_of_mem
 #align add_submonoid.mem_Sup_of_mem AddSubmonoid.mem_sSup_of_mem
+-/
 
+#print Submonoid.iSup_induction /-
 /-- An induction principle for elements of `⨆ i, S i`.
 If `C` holds for `1` and all elements of `S i` for all `i`, and is preserved under multiplication,
 then it holds for all elements of the supremum of `S`. -/
@@ -280,7 +323,9 @@ theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {
   exact hp _ _ hi
 #align submonoid.supr_induction Submonoid.iSup_induction
 #align add_submonoid.supr_induction AddSubmonoid.iSup_induction
+-/
 
+#print Submonoid.iSup_induction' /-
 /-- A dependent version of `submonoid.supr_induction`. -/
 @[elab_as_elim, to_additive "A dependent version of `add_submonoid.supr_induction`. "]
 theorem iSup_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
@@ -296,6 +341,7 @@ theorem iSup_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x 
     refine' ⟨_, hmul _ _ _ _ Cx Cy⟩
 #align submonoid.supr_induction' Submonoid.iSup_induction'
 #align add_submonoid.supr_induction' AddSubmonoid.iSup_induction'
+-/
 
 end Submonoid
 
@@ -307,6 +353,7 @@ variable {α : Type _}
 
 open Submonoid
 
+#print FreeMonoid.closure_range_of /-
 @[to_additive]
 theorem closure_range_of : closure (Set.range <| @of α) = ⊤ :=
   eq_top_iff.2 fun x hx =>
@@ -314,6 +361,7 @@ theorem closure_range_of : closure (Set.range <| @of α) = ⊤ :=
       mul_mem (subset_closure <| Set.mem_range_self _) hxs
 #align free_monoid.closure_range_of FreeMonoid.closure_range_of
 #align free_add_monoid.closure_range_of FreeAddMonoid.closure_range_of
+-/
 
 end FreeMonoid
 
@@ -330,19 +378,25 @@ theorem closure_singleton_eq (x : M) : closure ({x} : Set M) = (powersHom M x).m
 #align submonoid.closure_singleton_eq Submonoid.closure_singleton_eq
 -/
 
+#print Submonoid.mem_closure_singleton /-
 /-- The submonoid generated by an element of a monoid equals the set of natural number powers of
     the element. -/
 theorem mem_closure_singleton {x y : M} : y ∈ closure ({x} : Set M) ↔ ∃ n : ℕ, x ^ n = y := by
   rw [closure_singleton_eq, mem_mrange] <;> rfl
 #align submonoid.mem_closure_singleton Submonoid.mem_closure_singleton
+-/
 
+#print Submonoid.mem_closure_singleton_self /-
 theorem mem_closure_singleton_self {y : M} : y ∈ closure ({y} : Set M) :=
   mem_closure_singleton.2 ⟨1, pow_one y⟩
 #align submonoid.mem_closure_singleton_self Submonoid.mem_closure_singleton_self
+-/
 
+#print Submonoid.closure_singleton_one /-
 theorem closure_singleton_one : closure ({1} : Set M) = ⊥ := by
   simp [eq_bot_iff_forall, mem_closure_singleton]
 #align submonoid.closure_singleton_one Submonoid.closure_singleton_one
+-/
 
 #print FreeMonoid.mrange_lift /-
 @[to_additive]
@@ -362,6 +416,7 @@ theorem closure_eq_mrange (s : Set M) : closure s = (FreeMonoid.lift (coe : s 
 #align add_submonoid.closure_eq_mrange AddSubmonoid.closure_eq_mrange
 -/
 
+#print Submonoid.closure_eq_image_prod /-
 @[to_additive]
 theorem closure_eq_image_prod (s : Set M) :
     (closure s : Set M) = List.prod '' {l : List M | ∀ x ∈ l, x ∈ s} :=
@@ -370,14 +425,18 @@ theorem closure_eq_image_prod (s : Set M) :
   exact congr_arg _ (funext <| FreeMonoid.lift_apply _)
 #align submonoid.closure_eq_image_prod Submonoid.closure_eq_image_prod
 #align add_submonoid.closure_eq_image_sum AddSubmonoid.closure_eq_image_sum
+-/
 
+#print Submonoid.exists_list_of_mem_closure /-
 @[to_additive]
 theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
     ∃ (l : List M) (hl : ∀ y ∈ l, y ∈ s), l.Prod = x := by
   rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image_iff_bex] at hx 
 #align submonoid.exists_list_of_mem_closure Submonoid.exists_list_of_mem_closure
 #align add_submonoid.exists_list_of_mem_closure AddSubmonoid.exists_list_of_mem_closure
+-/
 
+#print Submonoid.exists_multiset_of_mem_closure /-
 @[to_additive]
 theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {x : M}
     (hx : x ∈ closure s) : ∃ (l : Multiset M) (hl : ∀ y ∈ l, y ∈ s), l.Prod = x :=
@@ -386,7 +445,9 @@ theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {
   exact ⟨l, h1, (Multiset.coe_prod l).trans h2⟩
 #align submonoid.exists_multiset_of_mem_closure Submonoid.exists_multiset_of_mem_closure
 #align add_submonoid.exists_multiset_of_mem_closure AddSubmonoid.exists_multiset_of_mem_closure
+-/
 
+#print Submonoid.closure_induction_left /-
 @[to_additive]
 theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
     (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
@@ -398,14 +459,18 @@ theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ c
   · simpa only [map_mul, FreeMonoid.lift_eval_of] using Hmul _ x.prop _ ih
 #align submonoid.closure_induction_left Submonoid.closure_induction_left
 #align add_submonoid.closure_induction_left AddSubmonoid.closure_induction_left
+-/
 
+#print Submonoid.induction_of_closure_eq_top_left /-
 @[elab_as_elim, to_additive]
 theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
   closure_induction_left (by rw [hs]; exact mem_top _) H1 Hmul
 #align submonoid.induction_of_closure_eq_top_left Submonoid.induction_of_closure_eq_top_left
 #align add_submonoid.induction_of_closure_eq_top_left AddSubmonoid.induction_of_closure_eq_top_left
+-/
 
+#print Submonoid.closure_induction_right /-
 @[to_additive]
 theorem closure_induction_right {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
     (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
@@ -414,13 +479,16 @@ theorem closure_induction_right {s : Set M} {p : M → Prop} {x : M} (h : x ∈
     H1 fun x hx y => Hmul _ _ hx
 #align submonoid.closure_induction_right Submonoid.closure_induction_right
 #align add_submonoid.closure_induction_right AddSubmonoid.closure_induction_right
+-/
 
+#print Submonoid.induction_of_closure_eq_top_right /-
 @[elab_as_elim, to_additive]
 theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
   closure_induction_right (by rw [hs]; exact mem_top _) H1 Hmul
 #align submonoid.induction_of_closure_eq_top_right Submonoid.induction_of_closure_eq_top_right
 #align add_submonoid.induction_of_closure_eq_top_right AddSubmonoid.induction_of_closure_eq_top_right
+-/
 
 #print Submonoid.powers /-
 /-- The submonoid generated by an element. -/
@@ -430,19 +498,25 @@ def powers (n : M) : Submonoid M :=
 #align submonoid.powers Submonoid.powers
 -/
 
+#print Submonoid.mem_powers /-
 @[simp]
 theorem mem_powers (n : M) : n ∈ powers n :=
   ⟨1, pow_one _⟩
 #align submonoid.mem_powers Submonoid.mem_powers
+-/
 
+#print Submonoid.coe_powers /-
 @[norm_cast]
 theorem coe_powers (x : M) : ↑(powers x) = Set.range fun n : ℕ => x ^ n :=
   rfl
 #align submonoid.coe_powers Submonoid.coe_powers
+-/
 
+#print Submonoid.mem_powers_iff /-
 theorem mem_powers_iff (x z : M) : x ∈ powers z ↔ ∃ n : ℕ, z ^ n = x :=
   Iff.rfl
 #align submonoid.mem_powers_iff Submonoid.mem_powers_iff
+-/
 
 #print Submonoid.powers_eq_closure /-
 theorem powers_eq_closure (n : M) : powers n = closure {n} := by ext;
@@ -450,40 +524,54 @@ theorem powers_eq_closure (n : M) : powers n = closure {n} := by ext;
 #align submonoid.powers_eq_closure Submonoid.powers_eq_closure
 -/
 
+#print Submonoid.powers_subset /-
 theorem powers_subset {n : M} {P : Submonoid M} (h : n ∈ P) : powers n ≤ P := fun x hx =>
   match x, hx with
   | _, ⟨i, rfl⟩ => pow_mem h i
 #align submonoid.powers_subset Submonoid.powers_subset
+-/
 
+#print Submonoid.powers_one /-
 @[simp]
 theorem powers_one : powers (1 : M) = ⊥ :=
   bot_unique <| powers_subset (one_mem _)
 #align submonoid.powers_one Submonoid.powers_one
+-/
 
+#print Submonoid.pow /-
 /-- Exponentiation map from natural numbers to powers. -/
 @[simps]
 def pow (n : M) (m : ℕ) : powers n :=
   (powersHom M n).mrangeRestrict (Multiplicative.ofAdd m)
 #align submonoid.pow Submonoid.pow
+-/
 
+#print Submonoid.pow_apply /-
 theorem pow_apply (n : M) (m : ℕ) : Submonoid.pow n m = ⟨n ^ m, m, rfl⟩ :=
   rfl
 #align submonoid.pow_apply Submonoid.pow_apply
+-/
 
+#print Submonoid.log /-
 /-- Logarithms from powers to natural numbers. -/
 def log [DecidableEq M] {n : M} (p : powers n) : ℕ :=
   Nat.find <| (mem_powers_iff p.val n).mp p.Prop
 #align submonoid.log Submonoid.log
+-/
 
+#print Submonoid.pow_log_eq_self /-
 @[simp]
 theorem pow_log_eq_self [DecidableEq M] {n : M} (p : powers n) : pow n (log p) = p :=
   Subtype.ext <| Nat.find_spec p.Prop
 #align submonoid.pow_log_eq_self Submonoid.pow_log_eq_self
+-/
 
+#print Submonoid.pow_right_injective_iff_pow_injective /-
 theorem pow_right_injective_iff_pow_injective {n : M} :
     (Function.Injective fun m : ℕ => n ^ m) ↔ Function.Injective (pow n) :=
   Subtype.coe_injective.of_comp_iff (pow n)
 #align submonoid.pow_right_injective_iff_pow_injective Submonoid.pow_right_injective_iff_pow_injective
+-/
 
 #print Submonoid.log_pow_eq_self /-
 @[simp]
@@ -493,6 +581,7 @@ theorem log_pow_eq_self [DecidableEq M] {n : M} (h : Function.Injective fun m :
 #align submonoid.log_pow_eq_self Submonoid.log_pow_eq_self
 -/
 
+#print Submonoid.powLogEquiv /-
 /-- The exponentiation map is an isomorphism from the additive monoid on natural numbers to powers
 when it is injective. The inverse is given by the logarithms. -/
 @[simps]
@@ -504,23 +593,31 @@ def powLogEquiv [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n
   right_inv := pow_log_eq_self
   map_mul' _ _ := by simp only [pow, map_mul, ofAdd_add, toAdd_mul]
 #align submonoid.pow_log_equiv Submonoid.powLogEquiv
+-/
 
+#print Submonoid.log_mul /-
 theorem log_mul [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)
     (x y : powers (n : M)) : log (x * y) = log x + log y :=
   (powLogEquiv h).symm.map_mul x y
 #align submonoid.log_mul Submonoid.log_mul
+-/
 
+#print Submonoid.log_pow_int_eq_self /-
 theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x m) = m :=
   (powLogEquiv (Int.pow_right_injective h)).symm_apply_apply _
 #align submonoid.log_pow_int_eq_self Submonoid.log_pow_int_eq_self
+-/
 
+#print Submonoid.map_powers /-
 @[simp]
 theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :
     (powers m).map f = powers (f m) := by
   simp only [powers_eq_closure, map_mclosure f, Set.image_singleton]
 #align submonoid.map_powers Submonoid.map_powers
+-/
 
 /- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+#print Submonoid.closureCommMonoidOfComm /-
 /-- If all the elements of a set `s` commute, then `closure s` is a commutative monoid. -/
 @[to_additive
       "If all the elements of a set `s` commute, then `closure s` forms an additive\ncommutative monoid."]
@@ -535,9 +632,11 @@ def closureCommMonoidOfComm {s : Set M} (hcomm : ∀ (a) (_ : a ∈ s) (b) (_ :
           (fun x y z => Commute.mul_left) fun x y z => Commute.mul_right }
 #align submonoid.closure_comm_monoid_of_comm Submonoid.closureCommMonoidOfComm
 #align add_submonoid.closure_add_comm_monoid_of_comm AddSubmonoid.closureAddCommMonoidOfComm
+-/
 
 end Submonoid
 
+#print IsScalarTower.of_mclosure_eq_top /-
 @[to_additive]
 theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α]
     {s : Set M} (htop : Submonoid.closure s = ⊤)
@@ -548,7 +647,9 @@ theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul
   · clear x; intro x hx x' hx' y z; rw [mul_smul, mul_smul, hs x hx, hx']
 #align is_scalar_tower.of_mclosure_eq_top IsScalarTower.of_mclosure_eq_top
 #align vadd_assoc_class.of_mclosure_eq_top VAddAssocClass.of_mclosure_eq_top
+-/
 
+#print SMulCommClass.of_mclosure_eq_top /-
 @[to_additive]
 theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulAction M α] {s : Set M}
     (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x • y • z = y • x • z) :
@@ -559,6 +660,7 @@ theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulActio
   · clear x; intro x hx x' hx' y z; rw [mul_smul, mul_smul, hx', hs x hx]
 #align smul_comm_class.of_mclosure_eq_top SMulCommClass.of_mclosure_eq_top
 #align vadd_comm_class.of_mclosure_eq_top VAddCommClass.of_mclosure_eq_top
+-/
 
 namespace Submonoid
 
@@ -566,19 +668,23 @@ variable {N : Type _} [CommMonoid N]
 
 open MonoidHom
 
+#print Submonoid.sup_eq_range /-
 @[to_additive]
 theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = (s.Subtype.coprod t.Subtype).mrange := by
   rw [mrange_eq_map, ← mrange_inl_sup_mrange_inr, map_sup, map_mrange, coprod_comp_inl, map_mrange,
     coprod_comp_inr, range_subtype, range_subtype]
 #align submonoid.sup_eq_range Submonoid.sup_eq_range
 #align add_submonoid.sup_eq_range AddSubmonoid.sup_eq_range
+-/
 
+#print Submonoid.mem_sup /-
 @[to_additive]
 theorem mem_sup {s t : Submonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x := by
   simp only [sup_eq_range, mem_mrange, coprod_apply, Prod.exists, SetLike.exists, coeSubtype,
     Subtype.coe_mk]
 #align submonoid.mem_sup Submonoid.mem_sup
 #align add_submonoid.mem_sup AddSubmonoid.mem_sup
+-/
 
 end Submonoid
 
@@ -595,15 +701,19 @@ theorem closure_singleton_eq (x : A) : closure ({x} : Set A) = (multiplesHom A x
 #align add_submonoid.closure_singleton_eq AddSubmonoid.closure_singleton_eq
 -/
 
+#print AddSubmonoid.mem_closure_singleton /-
 /-- The `add_submonoid` generated by an element of an `add_monoid` equals the set of
 natural number multiples of the element. -/
 theorem mem_closure_singleton {x y : A} : y ∈ closure ({x} : Set A) ↔ ∃ n : ℕ, n • x = y := by
   rw [closure_singleton_eq, AddMonoidHom.mem_mrange] <;> rfl
 #align add_submonoid.mem_closure_singleton AddSubmonoid.mem_closure_singleton
+-/
 
+#print AddSubmonoid.closure_singleton_zero /-
 theorem closure_singleton_zero : closure ({0} : Set A) = ⊥ := by
   simp [eq_bot_iff_forall, mem_closure_singleton, nsmul_zero]
 #align add_submonoid.closure_singleton_zero AddSubmonoid.closure_singleton_zero
+-/
 
 #print AddSubmonoid.multiples /-
 /-- The additive submonoid generated by an element. -/
@@ -637,6 +747,7 @@ namespace MulMemClass
 variable {R : Type _} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M}
   {a b : R}
 
+#print MulMemClass.mul_right_mem_add_closure /-
 /-- The product of an element of the additive closure of a multiplicative subsemigroup `M`
 and an element of `M` is contained in the additive closure of `M`. -/
 theorem mul_right_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R)) (hb : b ∈ S) :
@@ -651,7 +762,9 @@ theorem mul_right_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
   · simp_rw [add_mul]
     exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr hb) (hs hb)
 #align mul_mem_class.mul_right_mem_add_closure MulMemClass.mul_right_mem_add_closure
+-/
 
+#print MulMemClass.mul_mem_add_closure /-
 /-- The product of two elements of the additive closure of a submonoid `M` is an element of the
 additive closure of `M`. -/
 theorem mul_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
@@ -666,18 +779,22 @@ theorem mul_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
   · simp_rw [mul_add]
     exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr hb) (hs hb)
 #align mul_mem_class.mul_mem_add_closure MulMemClass.mul_mem_add_closure
+-/
 
+#print MulMemClass.mul_left_mem_add_closure /-
 /-- The product of an element of `S` and an element of the additive closure of a multiplicative
 submonoid `S` is contained in the additive closure of `S`. -/
 theorem mul_left_mem_add_closure (ha : a ∈ S) (hb : b ∈ AddSubmonoid.closure (S : Set R)) :
     a * b ∈ AddSubmonoid.closure (S : Set R) :=
   mul_mem_add_closure (AddSubmonoid.mem_closure.mpr fun sT hT => hT ha) hb
 #align mul_mem_class.mul_left_mem_add_closure MulMemClass.mul_left_mem_add_closure
+-/
 
 end MulMemClass
 
 namespace Submonoid
 
+#print Submonoid.mem_closure_pair /-
 /-- An element is in the closure of a two-element set if it is a linear combination of those two
 elements. -/
 @[to_additive
@@ -689,11 +806,13 @@ theorem mem_closure_pair {A : Type _} [CommMonoid A] (a b c : A) :
   simp_rw [exists_prop, mem_closure_singleton, exists_exists_eq_and]
 #align submonoid.mem_closure_pair Submonoid.mem_closure_pair
 #align add_submonoid.mem_closure_pair AddSubmonoid.mem_closure_pair
+-/
 
 end Submonoid
 
 section mul_add
 
+#print ofMul_image_powers_eq_multiples_ofMul /-
 theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
     Additive.ofMul '' (Submonoid.powers x : Set M) = AddSubmonoid.multiples (Additive.ofMul x) :=
   by
@@ -706,7 +825,9 @@ theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
     refine' ⟨x ^ n, ⟨n, rfl⟩, _⟩
     rwa [ofMul_pow]
 #align of_mul_image_powers_eq_multiples_of_mul ofMul_image_powers_eq_multiples_ofMul
+-/
 
+#print ofAdd_image_multiples_eq_powers_ofAdd /-
 theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
     Multiplicative.ofAdd '' (AddSubmonoid.multiples x : Set A) =
       Submonoid.powers (Multiplicative.ofAdd x) :=
@@ -715,6 +836,7 @@ theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
   rw [Equiv.eq_image_iff_symm_image_eq]
   exact ofMul_image_powers_eq_multiples_ofMul
 #align of_add_image_multiples_eq_powers_of_add ofAdd_image_multiples_eq_powers_ofAdd
+-/
 
 end mul_add
 

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

@@ -100,7 +100,7 @@ theorem multiset_prod_mem {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 @[to_additive
       "Sum of elements in an `add_submonoid` of an `add_comm_monoid` indexed by a `finset`\nis in the `add_submonoid`."]
 theorem prod_mem {M : Type _} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] {ι : Type _}
-    {t : Finset ι} {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : (∏ c in t, f c) ∈ S :=
+    {t : Finset ι} {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : ∏ c in t, f c ∈ S :=
   multiset_prod_mem (t.1.map f) fun x hx =>
     let ⟨i, hi, hix⟩ := Multiset.mem_map.1 hx
     hix ▸ h i hi
@@ -162,7 +162,7 @@ theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h :
 @[to_additive
       "Sum of elements in an `add_submonoid` of an `add_comm_monoid` indexed by a `finset`\nis in the `add_submonoid`."]
 theorem prod_mem {M : Type _} [CommMonoid M] (S : Submonoid M) {ι : Type _} {t : Finset ι}
-    {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : (∏ c in t, f c) ∈ S :=
+    {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : ∏ c in t, f c ∈ S :=
   S.multiset_prod_mem (t.1.map f) fun x hx =>
     let ⟨i, hi, hix⟩ := Multiset.mem_map.1 hx
     hix ▸ h i hi

mathlib commit https://github.com/leanprover-community/mathlib/commit/31c24aa72e7b3e5ed97a8412470e904f82b81004

@@ -520,7 +520,7 @@ theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (
   simp only [powers_eq_closure, map_mclosure f, Set.image_singleton]
 #align submonoid.map_powers Submonoid.map_powers
 
-/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:638:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 /-- If all the elements of a set `s` commute, then `closure s` is a commutative monoid. -/
 @[to_additive
       "If all the elements of a set `s` commute, then `closure s` forms an additive\ncommutative monoid."]

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

@@ -364,7 +364,7 @@ theorem closure_eq_mrange (s : Set M) : closure s = (FreeMonoid.lift (coe : s 
 
 @[to_additive]
 theorem closure_eq_image_prod (s : Set M) :
-    (closure s : Set M) = List.prod '' { l : List M | ∀ x ∈ l, x ∈ s } :=
+    (closure s : Set M) = List.prod '' {l : List M | ∀ x ∈ l, x ∈ s} :=
   by
   rw [closure_eq_mrange, coe_mrange, ← Set.range_list_map_coe, ← Set.range_comp]
   exact congr_arg _ (funext <| FreeMonoid.lift_apply _)

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

@@ -274,7 +274,7 @@ then it holds for all elements of the supremum of `S`. -/
 theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
     (hp : ∀ (i), ∀ x ∈ S i, C x) (h1 : C 1) (hmul : ∀ x y, C x → C y → C (x * y)) : C x :=
   by
-  rw [supr_eq_closure] at hx
+  rw [supr_eq_closure] at hx 
   refine' closure_induction hx (fun x hx => _) h1 hmul
   obtain ⟨i, hi⟩ := set.mem_Union.mp hx
   exact hp _ _ hi
@@ -373,14 +373,14 @@ theorem closure_eq_image_prod (s : Set M) :
 
 @[to_additive]
 theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
-    ∃ (l : List M)(hl : ∀ y ∈ l, y ∈ s), l.Prod = x := by
-  rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image_iff_bex] at hx
+    ∃ (l : List M) (hl : ∀ y ∈ l, y ∈ s), l.Prod = x := by
+  rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image_iff_bex] at hx 
 #align submonoid.exists_list_of_mem_closure Submonoid.exists_list_of_mem_closure
 #align add_submonoid.exists_list_of_mem_closure AddSubmonoid.exists_list_of_mem_closure
 
 @[to_additive]
 theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {x : M}
-    (hx : x ∈ closure s) : ∃ (l : Multiset M)(hl : ∀ y ∈ l, y ∈ s), l.Prod = x :=
+    (hx : x ∈ closure s) : ∃ (l : Multiset M) (hl : ∀ y ∈ l, y ∈ s), l.Prod = x :=
   by
   obtain ⟨l, h1, h2⟩ := exists_list_of_mem_closure hx
   exact ⟨l, h1, (Multiset.coe_prod l).trans h2⟩
@@ -391,7 +391,7 @@ theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {
 theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
     (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
   by
-  rw [closure_eq_mrange] at h
+  rw [closure_eq_mrange] at h 
   obtain ⟨l, rfl⟩ := h
   induction' l using FreeMonoid.recOn with x y ih
   · exact H1

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

@@ -41,7 +41,7 @@ submonoid, submonoids
 -/
 
 
-open BigOperators
+open scoped BigOperators
 
 variable {M A B : Type _}
 

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

@@ -51,12 +51,6 @@ variable [Monoid M] [SetLike B M] [SubmonoidClass B M] {S : B}
 
 namespace SubmonoidClass
 
-/- warning: submonoid_class.coe_list_prod -> SubmonoidClass.coe_list_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : SetLike.{u2, u1} B M] [_inst_3 : SubmonoidClass.{u2, u1} B M (Monoid.toMulOneClass.{u1} M _inst_1) _inst_2] {S : B} (l : List.{u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S)), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (coeBase.{succ u1, succ u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u2} M B (SetLike.hasMem.{u2, u1} B M _inst_2) x S))))) (List.prod.{u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) (MulMemClass.mul.{u1, u2} M B (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) _inst_2 (SubmonoidClass.to_mulMemClass.{u2, u1} B M (Monoid.toMulOneClass.{u1} M _inst_1) _inst_2 _inst_3) S) (OneMemClass.one.{u2, u1} B M _inst_2 (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SubmonoidClass.to_oneMemClass.{u2, u1} B M (Monoid.toMulOneClass.{u1} M _inst_1) _inst_2 _inst_3) S) l)) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.map.{u1, u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (coeBase.{succ u1, succ u1} (coeSort.{succ u2, succ (succ u1)} B Type.{u1} (SetLike.hasCoeToSort.{u2, u1} B M _inst_2) S) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u2} M B (SetLike.hasMem.{u2, u1} B M _inst_2) x S)))))) l))
-but is expected to have type
-  forall {M : Type.{u2}} {B : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : SetLike.{u1, u2} B M] [_inst_3 : SubmonoidClass.{u1, u2} B M (Monoid.toMulOneClass.{u2} M _inst_1) _inst_2] {S : B} (l : List.{u2} (Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_2) x S))), Eq.{succ u2} M (Subtype.val.{succ u2} M (fun (x : M) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) x (SetLike.coe.{u1, u2} B M _inst_2 S)) (List.prod.{u2} (Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_2) x S)) (MulOneClass.toMul.{u2} (Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_2) x S)) (Monoid.toMulOneClass.{u2} (Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_2) x S)) (SubmonoidClass.toMonoid.{u2, u1} M _inst_1 B _inst_2 _inst_3 S))) (OneMemClass.one.{u1, u2} B M _inst_2 (Monoid.toOne.{u2} M _inst_1) (SubmonoidClass.toOneMemClass.{u1, u2} B M (Monoid.toMulOneClass.{u2} M _inst_1) _inst_2 _inst_3) S) l)) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) (List.map.{u2, u2} (Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_2) x S)) M (Subtype.val.{succ u2} M (fun (x : M) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) x (SetLike.coe.{u1, u2} B M _inst_2 S))) l))
-Case conversion may be inaccurate. Consider using '#align submonoid_class.coe_list_prod SubmonoidClass.coe_list_prodₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_list_prod (l : List S) : (l.Prod : M) = (l.map coe).Prod :=
   (SubmonoidClass.Subtype S : _ →* M).map_list_prod l
@@ -72,12 +66,6 @@ theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 #align add_submonoid_class.coe_multiset_sum AddSubmonoidClass.coe_multiset_sum
 -/
 
-/- warning: submonoid_class.coe_finset_prod -> SubmonoidClass.coe_finset_prod is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} {S : B} {ι : Type.{u2}} {M : Type.{u3}} [_inst_4 : CommMonoid.{u3} M] [_inst_5 : SetLike.{u1, u3} B M] [_inst_6 : SubmonoidClass.{u1, u3} B M (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4)) _inst_5] (f : ι -> (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S)) (s : Finset.{u2} ι), Eq.{succ u3} M ((fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (HasLiftT.mk.{succ u3, succ u3} (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (CoeTCₓ.coe.{succ u3, succ u3} (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (coeBase.{succ u3, succ u3} (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (coeSubtype.{succ u3} M (fun (x : M) => Membership.Mem.{u3, u1} M B (SetLike.hasMem.{u1, u3} B M _inst_5) x S))))) (Finset.prod.{u3, u2} (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) ι (SubmonoidClass.toCommMonoid.{u3, u1} M _inst_4 B _inst_5 _inst_6 S) s (fun (i : ι) => f i))) (Finset.prod.{u3, u2} M ι _inst_4 s (fun (i : ι) => (fun (a : Type.{u3}) (b : Type.{u3}) [self : HasLiftT.{succ u3, succ u3} a b] => self.0) (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (HasLiftT.mk.{succ u3, succ u3} (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (CoeTCₓ.coe.{succ u3, succ u3} (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (coeBase.{succ u3, succ u3} (coeSort.{succ u1, succ (succ u3)} B Type.{u3} (SetLike.hasCoeToSort.{u1, u3} B M _inst_5) S) M (coeSubtype.{succ u3} M (fun (x : M) => Membership.Mem.{u3, u1} M B (SetLike.hasMem.{u1, u3} B M _inst_5) x S))))) (f i)))
-but is expected to have type
-  forall {B : Type.{u1}} {S : B} {ι : Type.{u3}} {M : Type.{u2}} [_inst_4 : CommMonoid.{u2} M] [_inst_5 : SetLike.{u1, u2} B M] [_inst_6 : SubmonoidClass.{u1, u2} B M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)) _inst_5] (f : ι -> (Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_5) x S))) (s : Finset.{u3} ι), Eq.{succ u2} M (Subtype.val.{succ u2} M (fun (x : M) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) x (SetLike.coe.{u1, u2} B M _inst_5 S)) (Finset.prod.{u2, u3} (Subtype.{succ u2} M (fun (x : M) => Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_5) x S)) ι (SubmonoidClass.toCommMonoid.{u2, u1} M _inst_4 B _inst_5 _inst_6 S) s (fun (i : ι) => f i))) (Finset.prod.{u2, u3} M ι _inst_4 s (fun (i : ι) => Subtype.val.{succ u2} M (fun (x : M) => Membership.mem.{u2, u2} M (Set.{u2} M) (Set.instMembershipSet.{u2} M) x (SetLike.coe.{u1, u2} B M _inst_5 S)) (f i)))
-Case conversion may be inaccurate. Consider using '#align submonoid_class.coe_finset_prod SubmonoidClass.coe_finset_prodₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_finset_prod {ι M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → S)
     (s : Finset ι) : ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
@@ -89,12 +77,6 @@ end SubmonoidClass
 
 open SubmonoidClass
 
-/- warning: list_prod_mem -> list_prod_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {B : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : SetLike.{u2, u1} B M] [_inst_3 : SubmonoidClass.{u2, u1} B M (Monoid.toMulOneClass.{u1} M _inst_1) _inst_2] {S : B} {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Membership.Mem.{u1, u2} M B (SetLike.hasMem.{u2, u1} B M _inst_2) x S)) -> (Membership.Mem.{u1, u2} M B (SetLike.hasMem.{u2, u1} B M _inst_2) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) S)
-but is expected to have type
-  forall {M : Type.{u2}} {B : Type.{u1}} [_inst_1 : Monoid.{u2} M] [_inst_2 : SetLike.{u1, u2} B M] [_inst_3 : SubmonoidClass.{u1, u2} B M (Monoid.toMulOneClass.{u2} M _inst_1) _inst_2] {S : B} {l : List.{u2} M}, (forall (x : M), (Membership.mem.{u2, u2} M (List.{u2} M) (List.instMembershipList.{u2} M) x l) -> (Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_2) x S)) -> (Membership.mem.{u2, u1} M B (SetLike.instMembership.{u1, u2} B M _inst_2) (List.prod.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Monoid.toOne.{u2} M _inst_1) l) S)
-Case conversion may be inaccurate. Consider using '#align list_prod_mem list_prod_memₓ'. -/
 /-- Product of a list of elements in a submonoid is in the submonoid. -/
 @[to_additive "Sum of a list of elements in an `add_submonoid` is in the `add_submonoid`."]
 theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ S) : l.Prod ∈ S := by
@@ -113,12 +95,6 @@ theorem multiset_prod_mem {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 #align multiset_sum_mem multiset_sum_mem
 -/
 
-/- warning: prod_mem -> prod_mem is a dubious translation:
-lean 3 declaration is
-  forall {B : Type.{u1}} {S : B} {M : Type.{u2}} [_inst_4 : CommMonoid.{u2} M] [_inst_5 : SetLike.{u1, u2} B M] [_inst_6 : SubmonoidClass.{u1, u2} B M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)) _inst_5] {ι : Type.{u3}} {t : Finset.{u3} ι} {f : ι -> M}, (forall (c : ι), (Membership.Mem.{u3, u3} ι (Finset.{u3} ι) (Finset.hasMem.{u3} ι) c t) -> (Membership.Mem.{u2, u1} M B (SetLike.hasMem.{u1, u2} B M _inst_5) (f c) S)) -> (Membership.Mem.{u2, u1} M B (SetLike.hasMem.{u1, u2} B M _inst_5) (Finset.prod.{u2, u3} M ι _inst_4 t (fun (c : ι) => f c)) S)
-but is expected to have type
-  forall {B : Type.{u2}} {S : B} {M : Type.{u3}} [_inst_4 : CommMonoid.{u3} M] [_inst_5 : SetLike.{u2, u3} B M] [_inst_6 : SubmonoidClass.{u2, u3} B M (Monoid.toMulOneClass.{u3} M (CommMonoid.toMonoid.{u3} M _inst_4)) _inst_5] {ι : Type.{u1}} {t : Finset.{u1} ι} {f : ι -> M}, (forall (c : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) c t) -> (Membership.mem.{u3, u2} M B (SetLike.instMembership.{u2, u3} B M _inst_5) (f c) S)) -> (Membership.mem.{u3, u2} M B (SetLike.instMembership.{u2, u3} B M _inst_5) (Finset.prod.{u3, u1} M ι _inst_4 t (fun (c : ι) => f c)) S)
-Case conversion may be inaccurate. Consider using '#align prod_mem prod_memₓ'. -/
 /-- Product of elements of a submonoid of a `comm_monoid` indexed by a `finset` is in the
     submonoid. -/
 @[to_additive
@@ -135,24 +111,12 @@ namespace Submonoid
 
 variable (s : Submonoid M)
 
-/- warning: submonoid.coe_list_prod -> Submonoid.coe_list_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (l : List.{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))) s)), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (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))) s) M (HasLiftT.mk.{succ u1, succ 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))) s) M (CoeTCₓ.coe.{succ u1, succ 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))) s) M (coeBase.{succ u1, succ 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))) s) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x s))))) (List.prod.{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))) s) (Submonoid.mul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s) (Submonoid.one.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s) l)) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (List.map.{u1, 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))) s) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (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))) s) M (HasLiftT.mk.{succ u1, succ 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))) s) M (CoeTCₓ.coe.{succ u1, succ 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))) s) M (coeBase.{succ u1, succ 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))) s) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x s)))))) l))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (l : List.{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 s))), Eq.{succ u1} M (Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) s)) (List.prod.{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 s)) (Submonoid.mul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s) (Submonoid.one.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s) l)) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) (List.map.{u1, 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 s)) M (Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) s))) l))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_list_prod Submonoid.coe_list_prodₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_list_prod (l : List s) : (l.Prod : M) = (l.map coe).Prod :=
   s.Subtype.map_list_prod l
 #align submonoid.coe_list_prod Submonoid.coe_list_prod
 #align add_submonoid.coe_list_sum AddSubmonoid.coe_list_sum
 
-/- warning: submonoid.coe_multiset_prod -> Submonoid.coe_multiset_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_4 : CommMonoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (m : Multiset.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S)), Eq.{succ u1} M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) x S))))) (Multiset.prod.{u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) (Submonoid.toCommMonoid.{u1} M _inst_4 S) m)) (Multiset.prod.{u1} M _inst_4 (Multiset.map.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (HasLiftT.mk.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (CoeTCₓ.coe.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (coeBase.{succ u1, succ u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) S) M (coeSubtype.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) x S)))))) m))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_4 : CommMonoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (m : Multiset.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) x S))), Eq.{succ u1} M (Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) S)) (Multiset.prod.{u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) x S)) (Submonoid.toCommMonoid.{u1} M _inst_4 S) m)) (Multiset.prod.{u1} M _inst_4 (Multiset.map.{u1, u1} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) x S)) M (Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) S))) m))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_multiset_prod Submonoid.coe_multiset_prodₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_multiset_prod {M} [CommMonoid M] (S : Submonoid M) (m : Multiset S) :
     (m.Prod : M) = (m.map coe).Prod :=
@@ -160,12 +124,6 @@ theorem coe_multiset_prod {M} [CommMonoid M] (S : Submonoid M) (m : Multiset S)
 #align submonoid.coe_multiset_prod Submonoid.coe_multiset_prod
 #align add_submonoid.coe_multiset_sum AddSubmonoid.coe_multiset_sum
 
-/- warning: submonoid.coe_finset_prod -> Submonoid.coe_finset_prod is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {M : Type.{u2}} [_inst_4 : CommMonoid.{u2} M] (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (f : ι -> (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S)) (s : Finset.{u1} ι), Eq.{succ u2} M ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (coeSubtype.{succ u2} M (fun (x : M) => Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) x S))))) (Finset.prod.{u2, u1} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) ι (Submonoid.toCommMonoid.{u2} M _inst_4 S) s (fun (i : ι) => f i))) (Finset.prod.{u2, u1} M ι _inst_4 s (fun (i : ι) => (fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (HasLiftT.mk.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (CoeTCₓ.coe.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (coeBase.{succ u2, succ u2} (coeSort.{succ u2, succ (succ u2)} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) Type.{u2} (SetLike.hasCoeToSort.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) S) M (coeSubtype.{succ u2} M (fun (x : M) => Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) x S))))) (f i)))
-but is expected to have type
-  forall {ι : Type.{u2}} {M : Type.{u1}} [_inst_4 : CommMonoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (f : ι -> (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) x S))) (s : Finset.{u2} ι), Eq.{succ u1} M (Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) S)) (Finset.prod.{u1, u2} (Subtype.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) x S)) ι (Submonoid.toCommMonoid.{u1} M _inst_4 S) s (fun (i : ι) => f i))) (Finset.prod.{u1, u2} M ι _inst_4 s (fun (i : ι) => Subtype.val.{succ u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) S)) (f i)))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_finset_prod Submonoid.coe_finset_prodₓ'. -/
 @[simp, norm_cast, to_additive]
 theorem coe_finset_prod {ι M} [CommMonoid M] (S : Submonoid M) (f : ι → S) (s : Finset ι) :
     ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
@@ -173,12 +131,6 @@ theorem coe_finset_prod {ι M} [CommMonoid M] (S : Submonoid M) (f : ι → S) (
 #align submonoid.coe_finset_prod Submonoid.coe_finset_prod
 #align add_submonoid.coe_finset_sum AddSubmonoid.coe_finset_sum
 
-/- warning: submonoid.list_prod_mem -> Submonoid.list_prod_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) {l : List.{u1} M}, (forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x s)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) s)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) {l : List.{u1} M}, (forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (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 s)) -> (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))) (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) s)
-Case conversion may be inaccurate. Consider using '#align submonoid.list_prod_mem Submonoid.list_prod_memₓ'. -/
 /-- Product of a list of elements in a submonoid is in the submonoid. -/
 @[to_additive "Sum of a list of elements in an `add_submonoid` is in the `add_submonoid`."]
 theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.Prod ∈ s := by
@@ -186,12 +138,6 @@ theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.Prod ∈ s :=
 #align submonoid.list_prod_mem Submonoid.list_prod_mem
 #align add_submonoid.list_sum_mem AddSubmonoid.list_sum_mem
 
-/- warning: submonoid.multiset_prod_mem -> Submonoid.multiset_prod_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_4 : CommMonoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (m : Multiset.{u1} M), (forall (a : M), (Membership.Mem.{u1, u1} M (Multiset.{u1} M) (Multiset.hasMem.{u1} M) a m) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) a S)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) (Multiset.prod.{u1} M _inst_4 m) S)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_4 : CommMonoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (m : Multiset.{u1} M), (forall (a : M), (Membership.mem.{u1, u1} M (Multiset.{u1} M) (Multiset.instMembershipMultiset.{u1} M) a m) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) a S)) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) (Multiset.prod.{u1} M _inst_4 m) S)
-Case conversion may be inaccurate. Consider using '#align submonoid.multiset_prod_mem Submonoid.multiset_prod_memₓ'. -/
 /-- Product of a multiset of elements in a submonoid of a `comm_monoid` is in the submonoid. -/
 @[to_additive
       "Sum of a multiset of elements in an `add_submonoid` of an `add_comm_monoid` is\nin the `add_submonoid`."]
@@ -201,12 +147,6 @@ theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
 #align submonoid.multiset_prod_mem Submonoid.multiset_prod_mem
 #align add_submonoid.multiset_sum_mem AddSubmonoid.multiset_sum_mem
 
-/- warning: submonoid.multiset_noncomm_prod_mem -> Submonoid.multiset_noncommProd_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (m : Multiset.{u1} M) (comm : Set.Pairwise.{u1} M (setOf.{u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Multiset.{u1} M) (Multiset.hasMem.{u1} M) x m)) (Commute.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))), (forall (x : M), (Membership.Mem.{u1, u1} M (Multiset.{u1} M) (Multiset.hasMem.{u1} M) x m) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x S)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Multiset.noncommProd.{u1} M _inst_1 m comm) S)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (m : Multiset.{u1} M) (comm : Set.Pairwise.{u1} M (setOf.{u1} M (fun (x : M) => Membership.mem.{u1, u1} M (Multiset.{u1} M) (Multiset.instMembershipMultiset.{u1} M) x m)) (Commute.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))), (forall (x : M), (Membership.mem.{u1, u1} M (Multiset.{u1} M) (Multiset.instMembershipMultiset.{u1} M) 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 S)) -> (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))) (Multiset.noncommProd.{u1} M _inst_1 m comm) S)
-Case conversion may be inaccurate. Consider using '#align submonoid.multiset_noncomm_prod_mem Submonoid.multiset_noncommProd_memₓ'. -/
 @[to_additive]
 theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h : ∀ x ∈ m, x ∈ S) :
     m.noncommProd comm ∈ S :=
@@ -217,12 +157,6 @@ theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h :
 #align submonoid.multiset_noncomm_prod_mem Submonoid.multiset_noncommProd_mem
 #align add_submonoid.multiset_noncomm_sum_mem AddSubmonoid.multiset_noncommSum_mem
 
-/- warning: submonoid.prod_mem -> Submonoid.prod_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_4 : CommMonoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) {ι : Type.{u2}} {t : Finset.{u2} ι} {f : ι -> M}, (forall (c : ι), (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) c t) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) (f c) S)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_4)))) (Finset.prod.{u1, u2} M ι _inst_4 t (fun (c : ι) => f c)) S)
-but is expected to have type
-  forall {M : Type.{u2}} [_inst_4 : CommMonoid.{u2} M] (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) {ι : Type.{u1}} {t : Finset.{u1} ι} {f : ι -> M}, (forall (c : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) c t) -> (Membership.mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) (f c) S)) -> (Membership.mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4))) M (Submonoid.instSetLikeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M (CommMonoid.toMonoid.{u2} M _inst_4)))) (Finset.prod.{u2, u1} M ι _inst_4 t (fun (c : ι) => f c)) S)
-Case conversion may be inaccurate. Consider using '#align submonoid.prod_mem Submonoid.prod_memₓ'. -/
 /-- Product of elements of a submonoid of a `comm_monoid` indexed by a `finset` is in the
     submonoid. -/
 @[to_additive
@@ -235,12 +169,6 @@ theorem prod_mem {M : Type _} [CommMonoid M] (S : Submonoid M) {ι : Type _} {t
 #align submonoid.prod_mem Submonoid.prod_mem
 #align add_submonoid.sum_mem AddSubmonoid.sum_mem
 
-/- warning: submonoid.noncomm_prod_mem -> Submonoid.noncommProd_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) {ι : Type.{u2}} (t : Finset.{u2} ι) (f : ι -> M) (comm : Set.Pairwise.{u2} ι ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Finset.{u2} ι) (Set.{u2} ι) (HasLiftT.mk.{succ u2, succ u2} (Finset.{u2} ι) (Set.{u2} ι) (CoeTCₓ.coe.{succ u2, succ u2} (Finset.{u2} ι) (Set.{u2} ι) (Finset.Set.hasCoeT.{u2} ι))) t) (fun (a : ι) (b : ι) => Commute.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (f a) (f b))), (forall (c : ι), (Membership.Mem.{u2, u2} ι (Finset.{u2} ι) (Finset.hasMem.{u2} ι) c t) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (f c) S)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (Finset.noncommProd.{u2, u1} ι M _inst_1 t f comm) S)
-but is expected to have type
-  forall {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) {ι : Type.{u1}} (t : Finset.{u1} ι) (f : ι -> M) (comm : Set.Pairwise.{u1} ι (Finset.toSet.{u1} ι t) (fun (a : ι) (b : ι) => Commute.{u2} M (MulOneClass.toMul.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (f a) (f b))), (forall (c : ι), (Membership.mem.{u1, u1} ι (Finset.{u1} ι) (Finset.instMembershipFinset.{u1} ι) c t) -> (Membership.mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (f c) S)) -> (Membership.mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (Finset.noncommProd.{u1, u2} ι M _inst_1 t f comm) S)
-Case conversion may be inaccurate. Consider using '#align submonoid.noncomm_prod_mem Submonoid.noncommProd_memₓ'. -/
 @[to_additive]
 theorem noncommProd_mem (S : Submonoid M) {ι : Type _} (t : Finset ι) (f : ι → M) (comm)
     (h : ∀ c ∈ t, f c ∈ S) : t.noncommProd f comm ∈ S :=
@@ -265,12 +193,6 @@ open Set
 
 namespace Submonoid
 
-/- warning: submonoid.mem_supr_of_directed -> Submonoid.mem_iSup_of_directed is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i))))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directedₓ'. -/
 -- TODO: this section can be generalized to `[submonoid_class B M] [complete_lattice B]`
 -- such that `complete_lattice.le` coincides with `set_like.le`
 @[to_additive]
@@ -288,12 +210,6 @@ theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (
 #align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directed
 #align add_submonoid.mem_supr_of_directed AddSubmonoid.mem_iSup_of_directed
 
-/- warning: submonoid.coe_supr_of_directed -> Submonoid.coe_iSup_of_directed is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Set.iUnion.{u1, u2} M ι (fun (i : ι) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (S i))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Set.iUnion.{u1, u2} M ι (fun (i : ι) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (S i))))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directedₓ'. -/
 @[to_additive]
 theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S) :
     ((⨆ i, S i : Submonoid M) : Set M) = ⋃ i, ↑(S i) :=
@@ -301,12 +217,6 @@ theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : D
 #align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directed
 #align add_submonoid.coe_supr_of_directed AddSubmonoid.coe_iSup_of_directed
 
-/- warning: submonoid.mem_Sup_of_directed_on -> Submonoid.mem_sSup_of_directedOn is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Exists.{0} (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => And (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x s))))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_Sup_of_directed_on Submonoid.mem_sSup_of_directedOnₓ'. -/
 @[to_additive]
 theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
     (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s :=
@@ -316,12 +226,6 @@ theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
 #align submonoid.mem_Sup_of_directed_on Submonoid.mem_sSup_of_directedOn
 #align add_submonoid.mem_Sup_of_directed_on AddSubmonoid.mem_sSup_of_directedOn
 
-/- warning: submonoid.coe_Sup_of_directed_on -> Submonoid.coe_sSup_of_directedOn is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Set.iUnion.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.iUnion.{u1, 0} M (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) s))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Set.iUnion.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.iUnion.{u1, 0} M (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) s))))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_Sup_of_directed_on Submonoid.coe_sSup_of_directedOnₓ'. -/
 @[to_additive]
 theorem coe_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
     (hS : DirectedOn (· ≤ ·) S) : (↑(sSup S) : Set M) = ⋃ s ∈ S, ↑s :=
@@ -329,48 +233,24 @@ theorem coe_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
 #align submonoid.coe_Sup_of_directed_on Submonoid.coe_sSup_of_directedOn
 #align add_submonoid.coe_Sup_of_directed_on AddSubmonoid.coe_sSup_of_directedOn
 
-/- warning: submonoid.mem_sup_left -> Submonoid.mem_sup_left is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x S) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x S) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_sup_left Submonoid.mem_sup_leftₓ'. -/
 @[to_additive]
 theorem mem_sup_left {S T : Submonoid M} : ∀ {x : M}, x ∈ S → x ∈ S ⊔ T :=
   show S ≤ S ⊔ T from le_sup_left
 #align submonoid.mem_sup_left Submonoid.mem_sup_left
 #align add_submonoid.mem_sup_left AddSubmonoid.mem_sup_left
 
-/- warning: submonoid.mem_sup_right -> Submonoid.mem_sup_right is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x T) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x T) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_sup_right Submonoid.mem_sup_rightₓ'. -/
 @[to_additive]
 theorem mem_sup_right {S T : Submonoid M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔ T :=
   show T ≤ S ⊔ T from le_sup_right
 #align submonoid.mem_sup_right Submonoid.mem_sup_right
 #align add_submonoid.mem_sup_right AddSubmonoid.mem_sup_right
 
-/- warning: submonoid.mul_mem_sup -> Submonoid.mul_mem_sup is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M} {y : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x S) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) y T) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y) (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M} {y : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x S) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) y T) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y) (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
-Case conversion may be inaccurate. Consider using '#align submonoid.mul_mem_sup Submonoid.mul_mem_supₓ'. -/
 @[to_additive]
 theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T :=
   (S ⊔ T).mul_mem (mem_sup_left hx) (mem_sup_right hy)
 #align submonoid.mul_mem_sup Submonoid.mul_mem_sup
 #align add_submonoid.add_mem_sup AddSubmonoid.add_mem_sup
 
-/- warning: submonoid.mem_supr_of_mem -> Submonoid.mem_iSup_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} {S : ι -> (Submonoid.{u1} M _inst_1)} (i : ι) {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι S))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} {S : ι -> (Submonoid.{u1} M _inst_1)} (i : ι) {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι S))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_supr_of_mem Submonoid.mem_iSup_of_memₓ'. -/
 @[to_additive]
 theorem mem_iSup_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
     ∀ {x : M}, x ∈ S i → x ∈ iSup S :=
@@ -378,12 +258,6 @@ theorem mem_iSup_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
 #align submonoid.mem_supr_of_mem Submonoid.mem_iSup_of_mem
 #align add_submonoid.mem_supr_of_mem AddSubmonoid.mem_iSup_of_mem
 
-/- warning: submonoid.mem_Sup_of_mem -> Submonoid.mem_sSup_of_mem is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)} {s : Submonoid.{u1} M _inst_1}, (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)} {s : Submonoid.{u1} M _inst_1}, (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) -> (forall {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x s) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_Sup_of_mem Submonoid.mem_sSup_of_memₓ'. -/
 @[to_additive]
 theorem mem_sSup_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
     ∀ {x : M}, x ∈ s → x ∈ sSup S :=
@@ -391,12 +265,6 @@ theorem mem_sSup_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S)
 #align submonoid.mem_Sup_of_mem Submonoid.mem_sSup_of_mem
 #align add_submonoid.mem_Sup_of_mem AddSubmonoid.mem_sSup_of_mem
 
-/- warning: submonoid.supr_induction -> Submonoid.iSup_induction is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : M -> Prop} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) -> (forall (i : ι) (x : M), (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)) -> (C x)) -> (C (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_1))))) -> (forall (x : M) (y : M), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y))) -> (C x)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : M -> Prop} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) -> (forall (i : ι) (x : M), (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)) -> (C x)) -> (C (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (MulOneClass.toOne.{u1} M _inst_1)))) -> (forall (x : M) (y : M), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y))) -> (C x)
-Case conversion may be inaccurate. Consider using '#align submonoid.supr_induction Submonoid.iSup_inductionₓ'. -/
 /-- An induction principle for elements of `⨆ i, S i`.
 If `C` holds for `1` and all elements of `S i` for all `i`, and is preserved under multiplication,
 then it holds for all elements of the supremum of `S`. -/
@@ -413,12 +281,6 @@ theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {
 #align submonoid.supr_induction Submonoid.iSup_induction
 #align add_submonoid.supr_induction AddSubmonoid.iSup_induction
 
-/- warning: submonoid.supr_induction' -> Submonoid.iSup_induction' is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : forall (x : M), (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) -> Prop}, (forall (i : ι) (x : M) (H : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)), C x (Submonoid.mem_iSup_of_mem.{u1, u2} M _inst_1 ι (fun (i : ι) => S i) i x H)) -> (C (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_1)))) (OneMemClass.one_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toHasOne.{u1} M _inst_1) (Submonoid.setLike.{u1} M _inst_1) (SubmonoidClass.to_oneMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.setLike.{u1} M _inst_1) (Submonoid.submonoidClass.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i)))) -> (forall (x : M) (y : M) (hx : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (hy : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) y (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))), (C x hx) -> (C y hy) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y) (MulMemClass.mul_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toHasMul.{u1} M _inst_1) (Submonoid.setLike.{u1} M _inst_1) (SubmonoidClass.to_mulMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.setLike.{u1} M _inst_1) (Submonoid.submonoidClass.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i)) x y hx hy))) -> (forall {x : M} (hx : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))), C x hx)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : forall (x : M), (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) -> Prop}, (forall (i : ι) (x : M) (H : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)), C x (Submonoid.mem_iSup_of_mem.{u1, u2} M _inst_1 ι (fun (i : ι) => S i) i x H)) -> (C (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (MulOneClass.toOne.{u1} M _inst_1))) (OneMemClass.one_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toOne.{u1} M _inst_1) (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SubmonoidClass.toOneMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (Submonoid.instSubmonoidClassSubmonoidInstSetLikeSubmonoid.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i)))) -> (forall (x : M) (y : M) (hx : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (hy : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) y (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))), (C x hx) -> (C y hy) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y) (MulMemClass.mul_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toMul.{u1} M _inst_1) (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SubmonoidClass.toMulMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (Submonoid.instSubmonoidClassSubmonoidInstSetLikeSubmonoid.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i)) x y hx hy))) -> (forall {x : M} (hx : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))), C x hx)
-Case conversion may be inaccurate. Consider using '#align submonoid.supr_induction' Submonoid.iSup_induction'ₓ'. -/
 /-- A dependent version of `submonoid.supr_induction`. -/
 @[elab_as_elim, to_additive "A dependent version of `add_submonoid.supr_induction`. "]
 theorem iSup_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
@@ -445,12 +307,6 @@ variable {α : Type _}
 
 open Submonoid
 
-/- warning: free_monoid.closure_range_of -> FreeMonoid.closure_range_of is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}}, Eq.{succ u1} (Submonoid.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.cancelMonoid.{u1} α))))) (Submonoid.closure.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.cancelMonoid.{u1} α)))) (Set.range.{u1, succ u1} (FreeMonoid.{u1} α) α (FreeMonoid.of.{u1} α))) (Top.top.{u1} (Submonoid.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.cancelMonoid.{u1} α))))) (Submonoid.hasTop.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.cancelMonoid.{u1} α))))))
-but is expected to have type
-  forall {α : Type.{u1}}, Eq.{succ u1} (Submonoid.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.instCancelMonoidFreeMonoid.{u1} α))))) (Submonoid.closure.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.instCancelMonoidFreeMonoid.{u1} α)))) (Set.range.{u1, succ u1} (FreeMonoid.{u1} α) α (FreeMonoid.of.{u1} α))) (Top.top.{u1} (Submonoid.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.instCancelMonoidFreeMonoid.{u1} α))))) (Submonoid.instTopSubmonoid.{u1} (FreeMonoid.{u1} α) (Monoid.toMulOneClass.{u1} (FreeMonoid.{u1} α) (RightCancelMonoid.toMonoid.{u1} (FreeMonoid.{u1} α) (CancelMonoid.toRightCancelMonoid.{u1} (FreeMonoid.{u1} α) (FreeMonoid.instCancelMonoidFreeMonoid.{u1} α))))))
-Case conversion may be inaccurate. Consider using '#align free_monoid.closure_range_of FreeMonoid.closure_range_ofₓ'. -/
 @[to_additive]
 theorem closure_range_of : closure (Set.range <| @of α) = ⊤ :=
   eq_top_iff.2 fun x hx =>
@@ -474,34 +330,16 @@ theorem closure_singleton_eq (x : M) : closure ({x} : Set M) = (powersHom M x).m
 #align submonoid.closure_singleton_eq Submonoid.closure_singleton_eq
 -/
 
-/- warning: submonoid.mem_closure_singleton -> Submonoid.mem_closure_singleton is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M} {y : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) y (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Singleton.singleton.{u1, u1} M (Set.{u1} M) (Set.hasSingleton.{u1} M) x))) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x n) y))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M} {y : M}, Iff (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))) y (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Singleton.singleton.{u1, u1} M (Set.{u1} M) (Set.instSingletonSet.{u1} M) x))) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x n) y))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_closure_singleton Submonoid.mem_closure_singletonₓ'. -/
 /-- The submonoid generated by an element of a monoid equals the set of natural number powers of
     the element. -/
 theorem mem_closure_singleton {x y : M} : y ∈ closure ({x} : Set M) ↔ ∃ n : ℕ, x ^ n = y := by
   rw [closure_singleton_eq, mem_mrange] <;> rfl
 #align submonoid.mem_closure_singleton Submonoid.mem_closure_singleton
 
-/- warning: submonoid.mem_closure_singleton_self -> Submonoid.mem_closure_singleton_self is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {y : M}, Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) y (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Singleton.singleton.{u1, u1} M (Set.{u1} M) (Set.hasSingleton.{u1} M) y))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {y : 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))) y (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Singleton.singleton.{u1, u1} M (Set.{u1} M) (Set.instSingletonSet.{u1} M) y))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_closure_singleton_self Submonoid.mem_closure_singleton_selfₓ'. -/
 theorem mem_closure_singleton_self {y : M} : y ∈ closure ({y} : Set M) :=
   mem_closure_singleton.2 ⟨1, pow_one y⟩
 #align submonoid.mem_closure_singleton_self Submonoid.mem_closure_singleton_self
 
-/- warning: submonoid.closure_singleton_one -> Submonoid.closure_singleton_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Singleton.singleton.{u1, u1} M (Set.{u1} M) (Set.hasSingleton.{u1} M) (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))))))) (Bot.bot.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasBot.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Singleton.singleton.{u1, u1} M (Set.{u1} M) (Set.instSingletonSet.{u1} M) (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1))))) (Bot.bot.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instBotSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align submonoid.closure_singleton_one Submonoid.closure_singleton_oneₓ'. -/
 theorem closure_singleton_one : closure ({1} : Set M) = ⊥ := by
   simp [eq_bot_iff_forall, mem_closure_singleton]
 #align submonoid.closure_singleton_one Submonoid.closure_singleton_one
@@ -524,12 +362,6 @@ theorem closure_eq_mrange (s : Set M) : closure s = (FreeMonoid.lift (coe : s 
 #align add_submonoid.closure_eq_mrange AddSubmonoid.closure_eq_mrange
 -/
 
-/- warning: submonoid.closure_eq_image_prod -> Submonoid.closure_eq_image_prod is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M), Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (SetLike.Set.hasCoeT.{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)) (Set.image.{u1, u1} (List.{u1} M) M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) (setOf.{u1} (List.{u1} M) (fun (l : List.{u1} M) => forall (x : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) x l) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) x s))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (s : Set.{u1} M), Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s)) (Set.image.{u1, u1} (List.{u1} M) M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1)) (setOf.{u1} (List.{u1} M) (fun (l : List.{u1} M) => forall (x : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) x l) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x s))))
-Case conversion may be inaccurate. Consider using '#align submonoid.closure_eq_image_prod Submonoid.closure_eq_image_prodₓ'. -/
 @[to_additive]
 theorem closure_eq_image_prod (s : Set M) :
     (closure s : Set M) = List.prod '' { l : List M | ∀ x ∈ l, x ∈ s } :=
@@ -539,12 +371,6 @@ theorem closure_eq_image_prod (s : Set M) :
 #align submonoid.closure_eq_image_prod Submonoid.closure_eq_image_prod
 #align add_submonoid.closure_eq_image_sum AddSubmonoid.closure_eq_image_sum
 
-/- warning: submonoid.exists_list_of_mem_closure -> Submonoid.exists_list_of_mem_closure is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s)) -> (Exists.{succ u1} (List.{u1} M) (fun (l : List.{u1} M) => Exists.{0} (forall (y : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) y l) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) y s)) (fun (hl : forall (y : M), (Membership.Mem.{u1, u1} M (List.{u1} M) (List.hasMem.{u1} M) y l) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) y s)) => Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) l) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {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)) -> (Exists.{succ u1} (List.{u1} M) (fun (l : List.{u1} M) => Exists.{0} (forall (y : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) y l) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) y s)) (fun (hl : forall (y : M), (Membership.mem.{u1, u1} M (List.{u1} M) (List.instMembershipList.{u1} M) y l) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) y s)) => Eq.{succ u1} M (List.prod.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Monoid.toOne.{u1} M _inst_1) l) x)))
-Case conversion may be inaccurate. Consider using '#align submonoid.exists_list_of_mem_closure Submonoid.exists_list_of_mem_closureₓ'. -/
 @[to_additive]
 theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
     ∃ (l : List M)(hl : ∀ y ∈ l, y ∈ s), l.Prod = x := by
@@ -552,12 +378,6 @@ theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
 #align submonoid.exists_list_of_mem_closure Submonoid.exists_list_of_mem_closure
 #align add_submonoid.exists_list_of_mem_closure AddSubmonoid.exists_list_of_mem_closure
 
-/- warning: submonoid.exists_multiset_of_mem_closure -> Submonoid.exists_multiset_of_mem_closure is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_2 : CommMonoid.{u1} M] {s : Set.{u1} M} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) s)) -> (Exists.{succ u1} (Multiset.{u1} M) (fun (l : Multiset.{u1} M) => Exists.{0} (forall (y : M), (Membership.Mem.{u1, u1} M (Multiset.{u1} M) (Multiset.hasMem.{u1} M) y l) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) y s)) (fun (hl : forall (y : M), (Membership.Mem.{u1, u1} M (Multiset.{u1} M) (Multiset.hasMem.{u1} M) y l) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) y s)) => Eq.{succ u1} M (Multiset.prod.{u1} M _inst_2 l) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_2 : CommMonoid.{u1} M] {s : Set.{u1} M} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2))) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M (CommMonoid.toMonoid.{u1} M _inst_2)) s)) -> (Exists.{succ u1} (Multiset.{u1} M) (fun (l : Multiset.{u1} M) => Exists.{0} (forall (y : M), (Membership.mem.{u1, u1} M (Multiset.{u1} M) (Multiset.instMembershipMultiset.{u1} M) y l) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) y s)) (fun (hl : forall (y : M), (Membership.mem.{u1, u1} M (Multiset.{u1} M) (Multiset.instMembershipMultiset.{u1} M) y l) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) y s)) => Eq.{succ u1} M (Multiset.prod.{u1} M _inst_2 l) x)))
-Case conversion may be inaccurate. Consider using '#align submonoid.exists_multiset_of_mem_closure Submonoid.exists_multiset_of_mem_closureₓ'. -/
 @[to_additive]
 theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {x : M}
     (hx : x ∈ closure s) : ∃ (l : Multiset M)(hl : ∀ y ∈ l, y ∈ s), l.Prod = x :=
@@ -567,12 +387,6 @@ theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {
 #align submonoid.exists_multiset_of_mem_closure Submonoid.exists_multiset_of_mem_closure
 #align add_submonoid.exists_multiset_of_mem_closure AddSubmonoid.exists_multiset_of_mem_closure
 
-/- warning: submonoid.closure_induction_left -> Submonoid.closure_induction_left is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s)) -> (p (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (forall (x : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) x s) -> (forall (y : M), (p y) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y)))) -> (p x)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop} {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)) -> (p (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (forall (x : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x s) -> (forall (y : M), (p y) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y)))) -> (p x)
-Case conversion may be inaccurate. Consider using '#align submonoid.closure_induction_left Submonoid.closure_induction_leftₓ'. -/
 @[to_additive]
 theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
     (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
@@ -585,12 +399,6 @@ theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ c
 #align submonoid.closure_induction_left Submonoid.closure_induction_left
 #align add_submonoid.closure_induction_left AddSubmonoid.closure_induction_left
 
-/- warning: submonoid.induction_of_closure_eq_top_left -> Submonoid.induction_of_closure_eq_top_left is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop}, (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)))) -> (forall (x : M), (p (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (forall (x : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) x s) -> (forall (y : M), (p y) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y)))) -> (p x))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop}, (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)))) -> (forall (x : M), (p (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (forall (x : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x s) -> (forall (y : M), (p y) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y)))) -> (p x))
-Case conversion may be inaccurate. Consider using '#align submonoid.induction_of_closure_eq_top_left Submonoid.induction_of_closure_eq_top_leftₓ'. -/
 @[elab_as_elim, to_additive]
 theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
@@ -598,12 +406,6 @@ theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : clos
 #align submonoid.induction_of_closure_eq_top_left Submonoid.induction_of_closure_eq_top_left
 #align add_submonoid.induction_of_closure_eq_top_left AddSubmonoid.induction_of_closure_eq_top_left
 
-/- warning: submonoid.closure_induction_right -> Submonoid.closure_induction_right is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) s)) -> (p (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (forall (x : M) (y : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) y s) -> (p x) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y))) -> (p x)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop} {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)) -> (p (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (forall (x : M) (y : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) y s) -> (p x) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y))) -> (p x)
-Case conversion may be inaccurate. Consider using '#align submonoid.closure_induction_right Submonoid.closure_induction_rightₓ'. -/
 @[to_additive]
 theorem closure_induction_right {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
     (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
@@ -613,12 +415,6 @@ theorem closure_induction_right {s : Set M} {p : M → Prop} {x : M} (h : x ∈
 #align submonoid.closure_induction_right Submonoid.closure_induction_right
 #align add_submonoid.closure_induction_right AddSubmonoid.closure_induction_right
 
-/- warning: submonoid.induction_of_closure_eq_top_right -> Submonoid.induction_of_closure_eq_top_right is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop}, (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)))) -> (forall (x : M), (p (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) -> (forall (x : M) (y : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) y s) -> (p x) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y))) -> (p x))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {p : M -> Prop}, (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)))) -> (forall (x : M), (p (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) -> (forall (x : M) (y : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) y s) -> (p x) -> (p (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x y))) -> (p x))
-Case conversion may be inaccurate. Consider using '#align submonoid.induction_of_closure_eq_top_right Submonoid.induction_of_closure_eq_top_rightₓ'. -/
 @[elab_as_elim, to_additive]
 theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
@@ -634,34 +430,16 @@ def powers (n : M) : Submonoid M :=
 #align submonoid.powers Submonoid.powers
 -/
 
-/- warning: submonoid.mem_powers -> Submonoid.mem_powers is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M), Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) n (Submonoid.powers.{u1} M _inst_1 n)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : 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))) n (Submonoid.powers.{u1} M _inst_1 n)
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_powers Submonoid.mem_powersₓ'. -/
 @[simp]
 theorem mem_powers (n : M) : n ∈ powers n :=
   ⟨1, pow_one _⟩
 #align submonoid.mem_powers Submonoid.mem_powers
 
-/- warning: submonoid.coe_powers -> Submonoid.coe_powers is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : M), Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (SetLike.Set.hasCoeT.{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 x)) (Set.range.{u1, 1} M Nat (fun (n : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x n))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : M), Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 x)) (Set.range.{u1, 1} M Nat (fun (n : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x n))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_powers Submonoid.coe_powersₓ'. -/
 @[norm_cast]
 theorem coe_powers (x : M) : ↑(powers x) = Set.range fun n : ℕ => x ^ n :=
   rfl
 #align submonoid.coe_powers Submonoid.coe_powers
 
-/- warning: submonoid.mem_powers_iff -> Submonoid.mem_powers_iff is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : M) (z : M), Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.powers.{u1} M _inst_1 z)) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) z n) x))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : M) (z : M), Iff (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 z)) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) z n) x))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_powers_iff Submonoid.mem_powers_iffₓ'. -/
 theorem mem_powers_iff (x z : M) : x ∈ powers z ↔ ∃ n : ℕ, z ^ n = x :=
   Iff.rfl
 #align submonoid.mem_powers_iff Submonoid.mem_powers_iff
@@ -672,78 +450,36 @@ theorem powers_eq_closure (n : M) : powers n = closure {n} := by ext;
 #align submonoid.powers_eq_closure Submonoid.powers_eq_closure
 -/
 
-/- warning: submonoid.powers_subset -> Submonoid.powers_subset is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {n : M} {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) n P) -> (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))))) (Submonoid.powers.{u1} M _inst_1 n) P)
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {n : M} {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (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))) n P) -> (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)))))) (Submonoid.powers.{u1} M _inst_1 n) P)
-Case conversion may be inaccurate. Consider using '#align submonoid.powers_subset Submonoid.powers_subsetₓ'. -/
 theorem powers_subset {n : M} {P : Submonoid M} (h : n ∈ P) : powers n ≤ P := fun x hx =>
   match x, hx with
   | _, ⟨i, rfl⟩ => pow_mem h i
 #align submonoid.powers_subset Submonoid.powers_subset
 
-/- warning: submonoid.powers_one -> Submonoid.powers_one is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Bot.bot.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.hasBot.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M], Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (Monoid.toOne.{u1} M _inst_1)))) (Bot.bot.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instBotSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align submonoid.powers_one Submonoid.powers_oneₓ'. -/
 @[simp]
 theorem powers_one : powers (1 : M) = ⊥ :=
   bot_unique <| powers_subset (one_mem _)
 #align submonoid.powers_one Submonoid.powers_one
 
-/- warning: submonoid.pow -> Submonoid.pow is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M), Nat -> (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 n))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M), Nat -> (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 n)))
-Case conversion may be inaccurate. Consider using '#align submonoid.pow Submonoid.powₓ'. -/
 /-- Exponentiation map from natural numbers to powers. -/
 @[simps]
 def pow (n : M) (m : ℕ) : powers n :=
   (powersHom M n).mrangeRestrict (Multiplicative.ofAdd m)
 #align submonoid.pow Submonoid.pow
 
-/- warning: submonoid.pow_apply -> Submonoid.pow_apply is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M) (m : Nat), Eq.{succ 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 n)) (Submonoid.pow.{u1} M _inst_1 n m) (Subtype.mk.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.powers.{u1} M _inst_1 n)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m) (Exists.intro.{1} Nat (fun (y : Nat) => Eq.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n y) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) m (rfl.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M) (m : Nat), Eq.{succ 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 n))) (Submonoid.pow.{u1} M _inst_1 n m) (Subtype.mk.{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 n)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m) (Exists.intro.{1} Nat (fun (y : Nat) => Eq.{succ u1} M ((fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 : M) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548 : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548) n y) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) m (rfl.{succ u1} M ((fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 : M) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548 : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548) n m))))
-Case conversion may be inaccurate. Consider using '#align submonoid.pow_apply Submonoid.pow_applyₓ'. -/
 theorem pow_apply (n : M) (m : ℕ) : Submonoid.pow n m = ⟨n ^ m, m, rfl⟩ :=
   rfl
 #align submonoid.pow_apply Submonoid.pow_apply
 
-/- warning: submonoid.log -> Submonoid.log is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M}, (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 n)) -> Nat
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M}, (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 n))) -> Nat
-Case conversion may be inaccurate. Consider using '#align submonoid.log Submonoid.logₓ'. -/
 /-- Logarithms from powers to natural numbers. -/
 def log [DecidableEq M] {n : M} (p : powers n) : ℕ :=
   Nat.find <| (mem_powers_iff p.val n).mp p.Prop
 #align submonoid.log Submonoid.log
 
-/- warning: submonoid.pow_log_eq_self -> Submonoid.pow_log_eq_self is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M} (p : 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 n)), Eq.{succ 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 n)) (Submonoid.pow.{u1} M _inst_1 n (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n p)) p
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M} (p : 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 n))), Eq.{succ 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 n))) (Submonoid.pow.{u1} M _inst_1 n (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n p)) p
-Case conversion may be inaccurate. Consider using '#align submonoid.pow_log_eq_self Submonoid.pow_log_eq_selfₓ'. -/
 @[simp]
 theorem pow_log_eq_self [DecidableEq M] {n : M} (p : powers n) : pow n (log p) = p :=
   Subtype.ext <| Nat.find_spec p.Prop
 #align submonoid.pow_log_eq_self Submonoid.pow_log_eq_self
 
-/- warning: submonoid.pow_right_injective_iff_pow_injective -> Submonoid.pow_right_injective_iff_pow_injective is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {n : M}, Iff (Function.Injective.{1, succ u1} Nat M (fun (m : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) (Function.Injective.{1, succ u1} Nat (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 n)) (Submonoid.pow.{u1} M _inst_1 n))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {n : M}, Iff (Function.Injective.{1, succ u1} Nat M (fun (m : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) (Function.Injective.{1, succ u1} Nat (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 n))) (Submonoid.pow.{u1} M _inst_1 n))
-Case conversion may be inaccurate. Consider using '#align submonoid.pow_right_injective_iff_pow_injective Submonoid.pow_right_injective_iff_pow_injectiveₓ'. -/
 theorem pow_right_injective_iff_pow_injective {n : M} :
     (Function.Injective fun m : ℕ => n ^ m) ↔ Function.Injective (pow n) :=
   Subtype.coe_injective.of_comp_iff (pow n)
@@ -757,12 +493,6 @@ theorem log_pow_eq_self [DecidableEq M] {n : M} (h : Function.Injective fun m :
 #align submonoid.log_pow_eq_self Submonoid.log_pow_eq_self
 -/
 
-/- warning: submonoid.pow_log_equiv -> Submonoid.powLogEquiv is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M}, (Function.Injective.{1, succ u1} Nat M (fun (m : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) -> (MulEquiv.{0, u1} (Multiplicative.{0} Nat) (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 n)) (Multiplicative.hasMul.{0} Nat Nat.hasAdd) (Submonoid.mul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Submonoid.powers.{u1} M _inst_1 n)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M}, (Function.Injective.{1, succ u1} Nat M (fun (m : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) -> (MulEquiv.{0, u1} (Multiplicative.{0} Nat) (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 n))) (Multiplicative.mul.{0} Nat instAddNat) (Submonoid.mul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Submonoid.powers.{u1} M _inst_1 n)))
-Case conversion may be inaccurate. Consider using '#align submonoid.pow_log_equiv Submonoid.powLogEquivₓ'. -/
 /-- The exponentiation map is an isomorphism from the additive monoid on natural numbers to powers
 when it is injective. The inverse is given by the logarithms. -/
 @[simps]
@@ -775,45 +505,21 @@ def powLogEquiv [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n
   map_mul' _ _ := by simp only [pow, map_mul, ofAdd_add, toAdd_mul]
 #align submonoid.pow_log_equiv Submonoid.powLogEquiv
 
-/- warning: submonoid.log_mul -> Submonoid.log_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M}, (Function.Injective.{1, succ u1} Nat M (fun (m : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) -> (forall (x : 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 n)) (y : 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 n)), Eq.{1} Nat (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n (HMul.hMul.{u1, u1, 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 n)) (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 n)) (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 n)) (instHMul.{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 n)) (Submonoid.mul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Submonoid.powers.{u1} M _inst_1 n))) x y)) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat Nat.hasAdd) (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n x) (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n y)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_2 : DecidableEq.{succ u1} M] {n : M}, (Function.Injective.{1, succ u1} Nat M (fun (m : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) -> (forall (x : 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 n))) (y : 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 n))), Eq.{1} Nat (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n (HMul.hMul.{u1, u1, 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 n))) (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 n))) (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 n))) (instHMul.{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 n))) (Submonoid.mul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (Submonoid.powers.{u1} M _inst_1 n))) x y)) (HAdd.hAdd.{0, 0, 0} Nat Nat Nat (instHAdd.{0} Nat instAddNat) (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n x) (Submonoid.log.{u1} M _inst_1 (fun (a : M) (b : M) => _inst_2 a b) n y)))
-Case conversion may be inaccurate. Consider using '#align submonoid.log_mul Submonoid.log_mulₓ'. -/
 theorem log_mul [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)
     (x y : powers (n : M)) : log (x * y) = log x + log y :=
   (powLogEquiv h).symm.map_mul x y
 #align submonoid.log_mul Submonoid.log_mul
 
-/- warning: submonoid.log_pow_int_eq_self -> Submonoid.log_pow_int_eq_self is a dubious translation:
-lean 3 declaration is
-  forall {x : Int}, (LT.lt.{0} Nat Nat.hasLt (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne))) (Int.natAbs x)) -> (forall (m : Nat), Eq.{1} Nat (Submonoid.log.{0} Int Int.monoid (fun (a : Int) (b : Int) => Int.decidableEq a b) x (Submonoid.pow.{0} Int Int.monoid x m)) m)
-but is expected to have type
-  forall {x : Int}, (LT.lt.{0} Nat instLTNat (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1)) (Int.natAbs x)) -> (forall (m : Nat), Eq.{1} Nat (Submonoid.log.{0} Int Int.instMonoidInt (fun (a : Int) (b : Int) => Int.instDecidableEqInt a b) x (Submonoid.pow.{0} Int Int.instMonoidInt x m)) m)
-Case conversion may be inaccurate. Consider using '#align submonoid.log_pow_int_eq_self Submonoid.log_pow_int_eq_selfₓ'. -/
 theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x m) = m :=
   (powLogEquiv (Int.pow_right_injective h)).symm_apply_apply _
 #align submonoid.log_pow_int_eq_self Submonoid.log_pow_int_eq_self
 
-/- warning: submonoid.map_powers -> Submonoid.map_powers is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u2}} {F : Type.{u3}} [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (m : M), Eq.{succ u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (Submonoid.map.{u1, u2, u3} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u2} N _inst_2 (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f m))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u3}} {F : Type.{u2}} [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) (m : M), Eq.{succ u3} (Submonoid.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (Submonoid.map.{u1, u3, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) m) _inst_2 (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u2, u1, u3} F M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3)) f m))
-Case conversion may be inaccurate. Consider using '#align submonoid.map_powers Submonoid.map_powersₓ'. -/
 @[simp]
 theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :
     (powers m).map f = powers (f m) := by
   simp only [powers_eq_closure, map_mclosure f, Set.image_singleton]
 #align submonoid.map_powers Submonoid.map_powers
 
-/- warning: submonoid.closure_comm_monoid_of_comm -> Submonoid.closureCommMonoidOfComm is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M}, (forall (a : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a s) -> (forall (b : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b s) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a)))) -> (CommMonoid.{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)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M}, (forall (a : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a s) -> (forall (b : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b s) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a)))) -> (CommMonoid.{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))))
-Case conversion may be inaccurate. Consider using '#align submonoid.closure_comm_monoid_of_comm Submonoid.closureCommMonoidOfCommₓ'. -/
 /- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 /-- If all the elements of a set `s` commute, then `closure s` is a commutative monoid. -/
 @[to_additive
@@ -832,12 +538,6 @@ def closureCommMonoidOfComm {s : Set M} (hcomm : ∀ (a) (_ : a ∈ s) (b) (_ :
 
 end Submonoid
 
-/- warning: is_scalar_tower.of_mclosure_eq_top -> IsScalarTower.of_mclosure_eq_top is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {α : Type.{u3}} [_inst_1 : Monoid.{u1} M] [_inst_2 : MulAction.{u1, u2} M N _inst_1] [_inst_3 : SMul.{u2, u3} N α] [_inst_4 : MulAction.{u1, u3} M α _inst_1] {s : Set.{u1} M}, (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)))) -> (forall (x : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) x s) -> (forall (y : N) (z : α), Eq.{succ u3} α (SMul.smul.{u2, u3} N α _inst_3 (SMul.smul.{u1, u2} M N (MulAction.toHasSmul.{u1, u2} M N _inst_1 _inst_2) x y) z) (SMul.smul.{u1, u3} M α (MulAction.toHasSmul.{u1, u3} M α _inst_1 _inst_4) x (SMul.smul.{u2, u3} N α _inst_3 y z)))) -> (IsScalarTower.{u1, u2, u3} M N α (MulAction.toHasSmul.{u1, u2} M N _inst_1 _inst_2) _inst_3 (MulAction.toHasSmul.{u1, u3} M α _inst_1 _inst_4))
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u3}} {α : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : MulAction.{u1, u3} M N _inst_1] [_inst_3 : SMul.{u3, u2} N α] [_inst_4 : MulAction.{u1, u2} M α _inst_1] {s : Set.{u1} M}, (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)))) -> (forall (x : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x s) -> (forall (y : N) (z : α), Eq.{succ u2} α (HSMul.hSMul.{u3, u2, u2} N α α (instHSMul.{u3, u2} N α _inst_3) (HSMul.hSMul.{u1, u3, u3} M N N (instHSMul.{u1, u3} M N (MulAction.toSMul.{u1, u3} M N _inst_1 _inst_2)) x y) z) (HSMul.hSMul.{u1, u2, u2} M α α (instHSMul.{u1, u2} M α (MulAction.toSMul.{u1, u2} M α _inst_1 _inst_4)) x (HSMul.hSMul.{u3, u2, u2} N α α (instHSMul.{u3, u2} N α _inst_3) y z)))) -> (IsScalarTower.{u1, u3, u2} M N α (MulAction.toSMul.{u1, u3} M N _inst_1 _inst_2) _inst_3 (MulAction.toSMul.{u1, u2} M α _inst_1 _inst_4))
-Case conversion may be inaccurate. Consider using '#align is_scalar_tower.of_mclosure_eq_top IsScalarTower.of_mclosure_eq_topₓ'. -/
 @[to_additive]
 theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α]
     {s : Set M} (htop : Submonoid.closure s = ⊤)
@@ -849,12 +549,6 @@ theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul
 #align is_scalar_tower.of_mclosure_eq_top IsScalarTower.of_mclosure_eq_top
 #align vadd_assoc_class.of_mclosure_eq_top VAddAssocClass.of_mclosure_eq_top
 
-/- warning: smul_comm_class.of_mclosure_eq_top -> SMulCommClass.of_mclosure_eq_top is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {N : Type.{u2}} {α : Type.{u3}} [_inst_1 : Monoid.{u1} M] [_inst_2 : SMul.{u2, u3} N α] [_inst_3 : MulAction.{u1, u3} M α _inst_1] {s : Set.{u1} M}, (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)))) -> (forall (x : M), (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) x s) -> (forall (y : N) (z : α), Eq.{succ u3} α (SMul.smul.{u1, u3} M α (MulAction.toHasSmul.{u1, u3} M α _inst_1 _inst_3) x (SMul.smul.{u2, u3} N α _inst_2 y z)) (SMul.smul.{u2, u3} N α _inst_2 y (SMul.smul.{u1, u3} M α (MulAction.toHasSmul.{u1, u3} M α _inst_1 _inst_3) x z)))) -> (SMulCommClass.{u1, u2, u3} M N α (MulAction.toHasSmul.{u1, u3} M α _inst_1 _inst_3) _inst_2)
-but is expected to have type
-  forall {M : Type.{u1}} {N : Type.{u3}} {α : Type.{u2}} [_inst_1 : Monoid.{u1} M] [_inst_2 : SMul.{u3, u2} N α] [_inst_3 : MulAction.{u1, u2} M α _inst_1] {s : Set.{u1} M}, (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)))) -> (forall (x : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) x s) -> (forall (y : N) (z : α), Eq.{succ u2} α (HSMul.hSMul.{u1, u2, u2} M α α (instHSMul.{u1, u2} M α (MulAction.toSMul.{u1, u2} M α _inst_1 _inst_3)) x (HSMul.hSMul.{u3, u2, u2} N α α (instHSMul.{u3, u2} N α _inst_2) y z)) (HSMul.hSMul.{u3, u2, u2} N α α (instHSMul.{u3, u2} N α _inst_2) y (HSMul.hSMul.{u1, u2, u2} M α α (instHSMul.{u1, u2} M α (MulAction.toSMul.{u1, u2} M α _inst_1 _inst_3)) x z)))) -> (SMulCommClass.{u1, u3, u2} M N α (MulAction.toSMul.{u1, u2} M α _inst_1 _inst_3) _inst_2)
-Case conversion may be inaccurate. Consider using '#align smul_comm_class.of_mclosure_eq_top SMulCommClass.of_mclosure_eq_topₓ'. -/
 @[to_additive]
 theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulAction M α] {s : Set M}
     (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x • y • z = y • x • z) :
@@ -872,9 +566,6 @@ variable {N : Type _} [CommMonoid N]
 
 open MonoidHom
 
-/- warning: submonoid.sup_eq_range -> Submonoid.sup_eq_range is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align submonoid.sup_eq_range Submonoid.sup_eq_rangeₓ'. -/
 @[to_additive]
 theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = (s.Subtype.coprod t.Subtype).mrange := by
   rw [mrange_eq_map, ← mrange_inl_sup_mrange_inr, map_sup, map_mrange, coprod_comp_inl, map_mrange,
@@ -882,12 +573,6 @@ theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = (s.Subtype.coprod t.Subtype
 #align submonoid.sup_eq_range Submonoid.sup_eq_range
 #align add_submonoid.sup_eq_range AddSubmonoid.sup_eq_range
 
-/- warning: submonoid.mem_sup -> Submonoid.mem_sup is a dubious translation:
-lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] {s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {x : N}, Iff (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.completeLattice.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t)) (Exists.{succ u1} N (fun (y : N) => Exists.{0} (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) (fun (H : Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) => Exists.{succ u1} N (fun (z : N) => Exists.{0} (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) (fun (H : Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) => Eq.{succ u1} N (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toHasMul.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y z) x)))))
-but is expected to have type
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] {s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {x : N}, Iff (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t)) (Exists.{succ u1} N (fun (y : N) => And (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) (Exists.{succ u1} N (fun (z : N) => And (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) (Eq.{succ u1} N (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y z) x)))))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_sup Submonoid.mem_supₓ'. -/
 @[to_additive]
 theorem mem_sup {s t : Submonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x := by
   simp only [sup_eq_range, mem_mrange, coprod_apply, Prod.exists, SetLike.exists, coeSubtype,
@@ -910,24 +595,12 @@ theorem closure_singleton_eq (x : A) : closure ({x} : Set A) = (multiplesHom A x
 #align add_submonoid.closure_singleton_eq AddSubmonoid.closure_singleton_eq
 -/
 
-/- warning: add_submonoid.mem_closure_singleton -> AddSubmonoid.mem_closure_singleton is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A} {y : A}, Iff (Membership.Mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.setLike.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1))) y (AddSubmonoid.closure.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1) (Singleton.singleton.{u1, u1} A (Set.{u1} A) (Set.hasSingleton.{u1} A) x))) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} A (SMul.smul.{0, u1} Nat A (AddMonoid.SMul.{u1} A _inst_1) n x) y))
-but is expected to have type
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A} {y : A}, Iff (Membership.mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1))) y (AddSubmonoid.closure.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1) (Singleton.singleton.{u1, u1} A (Set.{u1} A) (Set.instSingletonSet.{u1} A) x))) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} A (HSMul.hSMul.{0, u1, u1} Nat A A (instHSMul.{0, u1} Nat A (AddMonoid.SMul.{u1} A _inst_1)) n x) y))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mem_closure_singleton AddSubmonoid.mem_closure_singletonₓ'. -/
 /-- The `add_submonoid` generated by an element of an `add_monoid` equals the set of
 natural number multiples of the element. -/
 theorem mem_closure_singleton {x y : A} : y ∈ closure ({x} : Set A) ↔ ∃ n : ℕ, n • x = y := by
   rw [closure_singleton_eq, AddMonoidHom.mem_mrange] <;> rfl
 #align add_submonoid.mem_closure_singleton AddSubmonoid.mem_closure_singleton
 
-/- warning: add_submonoid.closure_singleton_zero -> AddSubmonoid.closure_singleton_zero is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A], Eq.{succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.closure.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1) (Singleton.singleton.{u1, u1} A (Set.{u1} A) (Set.hasSingleton.{u1} A) (OfNat.ofNat.{u1} A 0 (OfNat.mk.{u1} A 0 (Zero.zero.{u1} A (AddZeroClass.toHasZero.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1))))))) (Bot.bot.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.hasBot.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)))
-but is expected to have type
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A], Eq.{succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.closure.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1) (Singleton.singleton.{u1, u1} A (Set.{u1} A) (Set.instSingletonSet.{u1} A) (OfNat.ofNat.{u1} A 0 (Zero.toOfNat0.{u1} A (AddMonoid.toZero.{u1} A _inst_1))))) (Bot.bot.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.instBotAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.closure_singleton_zero AddSubmonoid.closure_singleton_zeroₓ'. -/
 theorem closure_singleton_zero : closure ({0} : Set A) = ⊥ := by
   simp [eq_bot_iff_forall, mem_closure_singleton, nsmul_zero]
 #align add_submonoid.closure_singleton_zero AddSubmonoid.closure_singleton_zero
@@ -964,12 +637,6 @@ namespace MulMemClass
 variable {R : Type _} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M}
   {a b : R}
 
-/- warning: mul_mem_class.mul_right_mem_add_closure -> MulMemClass.mul_right_mem_add_closure is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} R] [_inst_2 : SetLike.{u1, u2} M R] [_inst_3 : MulMemClass.{u1, u2} M R (Distrib.toHasMul.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R _inst_1)) _inst_2] {S : M} {a : R} {b : R}, (Membership.Mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.setLike.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) a (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u2}) [self : HasLiftT.{succ u1, succ u2} a b] => self.0) M (Set.{u2} R) (HasLiftT.mk.{succ u1, succ u2} M (Set.{u2} R) (CoeTCₓ.coe.{succ u1, succ u2} M (Set.{u2} R) (SetLike.Set.hasCoeT.{u1, u2} M R _inst_2))) S))) -> (Membership.Mem.{u2, u1} R M (SetLike.hasMem.{u1, u2} M R _inst_2) b S) -> (Membership.Mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.setLike.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R (Distrib.toHasMul.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R _inst_1))) a b) (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u2}) [self : HasLiftT.{succ u1, succ u2} a b] => self.0) M (Set.{u2} R) (HasLiftT.mk.{succ u1, succ u2} M (Set.{u2} R) (CoeTCₓ.coe.{succ u1, succ u2} M (Set.{u2} R) (SetLike.Set.hasCoeT.{u1, u2} M R _inst_2))) S)))
-but is expected to have type
-  forall {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} R] [_inst_2 : SetLike.{u1, u2} M R] [_inst_3 : MulMemClass.{u1, u2} M R (NonUnitalNonAssocSemiring.toMul.{u2} R _inst_1) _inst_2] {S : M} {a : R} {b : R}, (Membership.mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) a (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) (SetLike.coe.{u1, u2} M R _inst_2 S))) -> (Membership.mem.{u2, u1} R M (SetLike.instMembership.{u1, u2} M R _inst_2) b S) -> (Membership.mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R (NonUnitalNonAssocSemiring.toMul.{u2} R _inst_1)) a b) (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) (SetLike.coe.{u1, u2} M R _inst_2 S)))
-Case conversion may be inaccurate. Consider using '#align mul_mem_class.mul_right_mem_add_closure MulMemClass.mul_right_mem_add_closureₓ'. -/
 /-- The product of an element of the additive closure of a multiplicative subsemigroup `M`
 and an element of `M` is contained in the additive closure of `M`. -/
 theorem mul_right_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R)) (hb : b ∈ S) :
@@ -985,12 +652,6 @@ theorem mul_right_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
     exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr hb) (hs hb)
 #align mul_mem_class.mul_right_mem_add_closure MulMemClass.mul_right_mem_add_closure
 
-/- warning: mul_mem_class.mul_mem_add_closure -> MulMemClass.mul_mem_add_closure is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} R] [_inst_2 : SetLike.{u1, u2} M R] [_inst_3 : MulMemClass.{u1, u2} M R (Distrib.toHasMul.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R _inst_1)) _inst_2] {S : M} {a : R} {b : R}, (Membership.Mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.setLike.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) a (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u2}) [self : HasLiftT.{succ u1, succ u2} a b] => self.0) M (Set.{u2} R) (HasLiftT.mk.{succ u1, succ u2} M (Set.{u2} R) (CoeTCₓ.coe.{succ u1, succ u2} M (Set.{u2} R) (SetLike.Set.hasCoeT.{u1, u2} M R _inst_2))) S))) -> (Membership.Mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.setLike.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) b (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u2}) [self : HasLiftT.{succ u1, succ u2} a b] => self.0) M (Set.{u2} R) (HasLiftT.mk.{succ u1, succ u2} M (Set.{u2} R) (CoeTCₓ.coe.{succ u1, succ u2} M (Set.{u2} R) (SetLike.Set.hasCoeT.{u1, u2} M R _inst_2))) S))) -> (Membership.Mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.setLike.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R (Distrib.toHasMul.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R _inst_1))) a b) (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u2}) [self : HasLiftT.{succ u1, succ u2} a b] => self.0) M (Set.{u2} R) (HasLiftT.mk.{succ u1, succ u2} M (Set.{u2} R) (CoeTCₓ.coe.{succ u1, succ u2} M (Set.{u2} R) (SetLike.Set.hasCoeT.{u1, u2} M R _inst_2))) S)))
-but is expected to have type
-  forall {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} R] [_inst_2 : SetLike.{u1, u2} M R] [_inst_3 : MulMemClass.{u1, u2} M R (NonUnitalNonAssocSemiring.toMul.{u2} R _inst_1) _inst_2] {S : M} {a : R} {b : R}, (Membership.mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) a (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) (SetLike.coe.{u1, u2} M R _inst_2 S))) -> (Membership.mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) b (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) (SetLike.coe.{u1, u2} M R _inst_2 S))) -> (Membership.mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R (NonUnitalNonAssocSemiring.toMul.{u2} R _inst_1)) a b) (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) (SetLike.coe.{u1, u2} M R _inst_2 S)))
-Case conversion may be inaccurate. Consider using '#align mul_mem_class.mul_mem_add_closure MulMemClass.mul_mem_add_closureₓ'. -/
 /-- The product of two elements of the additive closure of a submonoid `M` is an element of the
 additive closure of `M`. -/
 theorem mul_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
@@ -1006,12 +667,6 @@ theorem mul_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
     exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr hb) (hs hb)
 #align mul_mem_class.mul_mem_add_closure MulMemClass.mul_mem_add_closure
 
-/- warning: mul_mem_class.mul_left_mem_add_closure -> MulMemClass.mul_left_mem_add_closure is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} R] [_inst_2 : SetLike.{u1, u2} M R] [_inst_3 : MulMemClass.{u1, u2} M R (Distrib.toHasMul.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R _inst_1)) _inst_2] {S : M} {a : R} {b : R}, (Membership.Mem.{u2, u1} R M (SetLike.hasMem.{u1, u2} M R _inst_2) a S) -> (Membership.Mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.setLike.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) b (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u2}) [self : HasLiftT.{succ u1, succ u2} a b] => self.0) M (Set.{u2} R) (HasLiftT.mk.{succ u1, succ u2} M (Set.{u2} R) (CoeTCₓ.coe.{succ u1, succ u2} M (Set.{u2} R) (SetLike.Set.hasCoeT.{u1, u2} M R _inst_2))) S))) -> (Membership.Mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.setLike.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R (Distrib.toHasMul.{u2} R (NonUnitalNonAssocSemiring.toDistrib.{u2} R _inst_1))) a b) (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) ((fun (a : Type.{u1}) (b : Type.{u2}) [self : HasLiftT.{succ u1, succ u2} a b] => self.0) M (Set.{u2} R) (HasLiftT.mk.{succ u1, succ u2} M (Set.{u2} R) (CoeTCₓ.coe.{succ u1, succ u2} M (Set.{u2} R) (SetLike.Set.hasCoeT.{u1, u2} M R _inst_2))) S)))
-but is expected to have type
-  forall {M : Type.{u1}} {R : Type.{u2}} [_inst_1 : NonUnitalNonAssocSemiring.{u2} R] [_inst_2 : SetLike.{u1, u2} M R] [_inst_3 : MulMemClass.{u1, u2} M R (NonUnitalNonAssocSemiring.toMul.{u2} R _inst_1) _inst_2] {S : M} {a : R} {b : R}, (Membership.mem.{u2, u1} R M (SetLike.instMembership.{u1, u2} M R _inst_2) a S) -> (Membership.mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) b (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) (SetLike.coe.{u1, u2} M R _inst_2 S))) -> (Membership.mem.{u2, u2} R (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))))) (HMul.hMul.{u2, u2, u2} R R R (instHMul.{u2} R (NonUnitalNonAssocSemiring.toMul.{u2} R _inst_1)) a b) (AddSubmonoid.closure.{u2} R (AddMonoid.toAddZeroClass.{u2} R (AddCommMonoid.toAddMonoid.{u2} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u2} R _inst_1))) (SetLike.coe.{u1, u2} M R _inst_2 S)))
-Case conversion may be inaccurate. Consider using '#align mul_mem_class.mul_left_mem_add_closure MulMemClass.mul_left_mem_add_closureₓ'. -/
 /-- The product of an element of `S` and an element of the additive closure of a multiplicative
 submonoid `S` is contained in the additive closure of `S`. -/
 theorem mul_left_mem_add_closure (ha : a ∈ S) (hb : b ∈ AddSubmonoid.closure (S : Set R)) :
@@ -1023,12 +678,6 @@ end MulMemClass
 
 namespace Submonoid
 
-/- warning: submonoid.mem_closure_pair -> Submonoid.mem_closure_pair is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u1}} [_inst_1 : CommMonoid.{u1} A] (a : A) (b : A) (c : A), Iff (Membership.Mem.{u1, u1} A (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) A (Submonoid.setLike.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1)))) c (Submonoid.closure.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1)) (Insert.insert.{u1, u1} A (Set.{u1} A) (Set.hasInsert.{u1} A) a (Singleton.singleton.{u1, u1} A (Set.{u1} A) (Set.hasSingleton.{u1} A) b)))) (Exists.{1} Nat (fun (m : Nat) => Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} A (HMul.hMul.{u1, u1, u1} A A A (instHMul.{u1} A (MulOneClass.toHasMul.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1)))) (HPow.hPow.{u1, 0, u1} A Nat A (instHPow.{u1, 0} A Nat (Monoid.Pow.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) a m) (HPow.hPow.{u1, 0, u1} A Nat A (instHPow.{u1, 0} A Nat (Monoid.Pow.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) b n)) c)))
-but is expected to have type
-  forall {A : Type.{u1}} [_inst_1 : CommMonoid.{u1} A] (a : A) (b : A) (c : A), Iff (Membership.mem.{u1, u1} A (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) A (Submonoid.instSetLikeSubmonoid.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1)))) c (Submonoid.closure.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1)) (Insert.insert.{u1, u1} A (Set.{u1} A) (Set.instInsertSet.{u1} A) a (Singleton.singleton.{u1, u1} A (Set.{u1} A) (Set.instSingletonSet.{u1} A) b)))) (Exists.{1} Nat (fun (m : Nat) => Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} A (HMul.hMul.{u1, u1, u1} A A A (instHMul.{u1} A (MulOneClass.toMul.{u1} A (Monoid.toMulOneClass.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1)))) (HPow.hPow.{u1, 0, u1} A Nat A (instHPow.{u1, 0} A Nat (Monoid.Pow.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) a m) (HPow.hPow.{u1, 0, u1} A Nat A (instHPow.{u1, 0} A Nat (Monoid.Pow.{u1} A (CommMonoid.toMonoid.{u1} A _inst_1))) b n)) c)))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_closure_pair Submonoid.mem_closure_pairₓ'. -/
 /-- An element is in the closure of a two-element set if it is a linear combination of those two
 elements. -/
 @[to_additive
@@ -1045,12 +694,6 @@ end Submonoid
 
 section mul_add
 
-/- warning: of_mul_image_powers_eq_multiples_of_mul -> ofMul_image_powers_eq_multiples_ofMul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) (fun (_x : Equiv.{succ u1, succ u1} M (Additive.{u1} M)) => M -> (Additive.{u1} M)) (Equiv.hasCoeToFun.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (SetLike.Set.hasCoeT.{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 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1)))))) (AddSubmonoid.multiples.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) (fun (_x : Equiv.{succ u1, succ u1} M (Additive.{u1} M)) => M -> (Additive.{u1} M)) (Equiv.hasCoeToFun.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.instSetLikeAddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (AddSubmonoid.multiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
-Case conversion may be inaccurate. Consider using '#align of_mul_image_powers_eq_multiples_of_mul ofMul_image_powers_eq_multiples_ofMulₓ'. -/
 theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
     Additive.ofMul '' (Submonoid.powers x : Set M) = AddSubmonoid.multiples (Additive.ofMul x) :=
   by
@@ -1064,12 +707,6 @@ theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
     rwa [ofMul_pow]
 #align of_mul_image_powers_eq_multiples_of_mul ofMul_image_powers_eq_multiples_ofMul
 
-/- warning: of_add_image_multiples_eq_powers_of_add -> ofAdd_image_multiples_eq_powers_ofAdd is a dubious translation:
-lean 3 declaration is
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.setLike.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1))))) (AddSubmonoid.multiples.{u1} A _inst_1 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.setLike.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1)))))) (Submonoid.powers.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
-but is expected to have type
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.multiples.{u1} A _inst_1 x))) (SetLike.coe.{u1, u1} (Submonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.instSetLikeSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Submonoid.powers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
-Case conversion may be inaccurate. Consider using '#align of_add_image_multiples_eq_powers_of_add ofAdd_image_multiples_eq_powers_ofAddₓ'. -/
 theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
     Multiplicative.ofAdd '' (AddSubmonoid.multiples x : Set A) =
       Submonoid.powers (Multiplicative.ofAdd x) :=

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

@@ -97,11 +97,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align list_prod_mem list_prod_memₓ'. -/
 /-- Product of a list of elements in a submonoid is in the submonoid. -/
 @[to_additive "Sum of a list of elements in an `add_submonoid` is in the `add_submonoid`."]
-theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ S) : l.Prod ∈ S :=
-  by
-  lift l to List S using hl
-  rw [← coe_list_prod]
-  exact l.prod.coe_prop
+theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ S) : l.Prod ∈ S := by
+  lift l to List S using hl; rw [← coe_list_prod]; exact l.prod.coe_prop
 #align list_prod_mem list_prod_mem
 #align list_sum_mem list_sum_mem
 
@@ -110,11 +107,8 @@ theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ S) : l.Prod ∈ S :=
 @[to_additive
       "Sum of a multiset of elements in an `add_submonoid` of an `add_comm_monoid` is\nin the `add_submonoid`."]
 theorem multiset_prod_mem {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (m : Multiset M)
-    (hm : ∀ a ∈ m, a ∈ S) : m.Prod ∈ S :=
-  by
-  lift m to Multiset S using hm
-  rw [← coe_multiset_prod]
-  exact m.prod.coe_prop
+    (hm : ∀ a ∈ m, a ∈ S) : m.Prod ∈ S := by lift m to Multiset S using hm;
+  rw [← coe_multiset_prod]; exact m.prod.coe_prop
 #align multiset_prod_mem multiset_prod_mem
 #align multiset_sum_mem multiset_sum_mem
 -/
@@ -187,11 +181,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align submonoid.list_prod_mem Submonoid.list_prod_memₓ'. -/
 /-- Product of a list of elements in a submonoid is in the submonoid. -/
 @[to_additive "Sum of a list of elements in an `add_submonoid` is in the `add_submonoid`."]
-theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.Prod ∈ s :=
-  by
-  lift l to List s using hl
-  rw [← coe_list_prod]
-  exact l.prod.coe_prop
+theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.Prod ∈ s := by
+  lift l to List s using hl; rw [← coe_list_prod]; exact l.prod.coe_prop
 #align submonoid.list_prod_mem Submonoid.list_prod_mem
 #align add_submonoid.list_sum_mem AddSubmonoid.list_sum_mem
 
@@ -205,11 +196,8 @@ Case conversion may be inaccurate. Consider using '#align submonoid.multiset_pro
 @[to_additive
       "Sum of a multiset of elements in an `add_submonoid` of an `add_comm_monoid` is\nin the `add_submonoid`."]
 theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
-    (hm : ∀ a ∈ m, a ∈ S) : m.Prod ∈ S :=
-  by
-  lift m to Multiset S using hm
-  rw [← coe_multiset_prod]
-  exact m.prod.coe_prop
+    (hm : ∀ a ∈ m, a ∈ S) : m.Prod ∈ S := by lift m to Multiset S using hm;
+  rw [← coe_multiset_prod]; exact m.prod.coe_prop
 #align submonoid.multiset_prod_mem Submonoid.multiset_prod_mem
 #align add_submonoid.multiset_sum_mem AddSubmonoid.multiset_sum_mem
 
@@ -606,11 +594,7 @@ Case conversion may be inaccurate. Consider using '#align submonoid.induction_of
 @[elab_as_elim, to_additive]
 theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
-  closure_induction_left
-    (by
-      rw [hs]
-      exact mem_top _)
-    H1 Hmul
+  closure_induction_left (by rw [hs]; exact mem_top _) H1 Hmul
 #align submonoid.induction_of_closure_eq_top_left Submonoid.induction_of_closure_eq_top_left
 #align add_submonoid.induction_of_closure_eq_top_left AddSubmonoid.induction_of_closure_eq_top_left
 
@@ -638,11 +622,7 @@ Case conversion may be inaccurate. Consider using '#align submonoid.induction_of
 @[elab_as_elim, to_additive]
 theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
-  closure_induction_right
-    (by
-      rw [hs]
-      exact mem_top _)
-    H1 Hmul
+  closure_induction_right (by rw [hs]; exact mem_top _) H1 Hmul
 #align submonoid.induction_of_closure_eq_top_right Submonoid.induction_of_closure_eq_top_right
 #align add_submonoid.induction_of_closure_eq_top_right AddSubmonoid.induction_of_closure_eq_top_right
 
@@ -687,9 +667,7 @@ theorem mem_powers_iff (x z : M) : x ∈ powers z ↔ ∃ n : ℕ, z ^ n = x :=
 #align submonoid.mem_powers_iff Submonoid.mem_powers_iff
 
 #print Submonoid.powers_eq_closure /-
-theorem powers_eq_closure (n : M) : powers n = closure {n} :=
-  by
-  ext
+theorem powers_eq_closure (n : M) : powers n = closure {n} := by ext;
   exact mem_closure_singleton.symm
 #align submonoid.powers_eq_closure Submonoid.powers_eq_closure
 -/
@@ -866,11 +844,8 @@ theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul
     (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z) : IsScalarTower M N α :=
   by
   refine' ⟨fun x => Submonoid.induction_of_closure_eq_top_left htop x _ _⟩
-  · intro y z
-    rw [one_smul, one_smul]
-  · clear x
-    intro x hx x' hx' y z
-    rw [mul_smul, mul_smul, hs x hx, hx']
+  · intro y z; rw [one_smul, one_smul]
+  · clear x; intro x hx x' hx' y z; rw [mul_smul, mul_smul, hs x hx, hx']
 #align is_scalar_tower.of_mclosure_eq_top IsScalarTower.of_mclosure_eq_top
 #align vadd_assoc_class.of_mclosure_eq_top VAddAssocClass.of_mclosure_eq_top
 
@@ -886,11 +861,8 @@ theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulActio
     SMulCommClass M N α :=
   by
   refine' ⟨fun x => Submonoid.induction_of_closure_eq_top_left htop x _ _⟩
-  · intro y z
-    rw [one_smul, one_smul]
-  · clear x
-    intro x hx x' hx' y z
-    rw [mul_smul, mul_smul, hx', hs x hx]
+  · intro y z; rw [one_smul, one_smul]
+  · clear x; intro x hx x' hx' y z; rw [mul_smul, mul_smul, hx', hs x hx]
 #align smul_comm_class.of_mclosure_eq_top SMulCommClass.of_mclosure_eq_top
 #align vadd_comm_class.of_mclosure_eq_top VAddCommClass.of_mclosure_eq_top
 

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

@@ -901,10 +901,7 @@ variable {N : Type _} [CommMonoid N]
 open MonoidHom
 
 /- warning: submonoid.sup_eq_range -> Submonoid.sup_eq_range is a dubious translation:
-lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] (s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))), Eq.{succ u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.completeLattice.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t) (MonoidHom.mrange.{u1, u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) (MonoidHom.{u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.coprod.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) N (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t) _inst_1 (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)))
-but is expected to have type
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] (s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))), Eq.{succ u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t) (MonoidHom.mrange.{u1, u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) (MonoidHom.{u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.coprod.{u1, u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) N (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t) _inst_1 (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)))
+<too large>
 Case conversion may be inaccurate. Consider using '#align submonoid.sup_eq_range Submonoid.sup_eq_rangeₓ'. -/
 @[to_additive]
 theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = (s.Subtype.coprod t.Subtype).mrange := by

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

@@ -822,7 +822,7 @@ theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u2}} {F : Type.{u3}} [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (m : M), Eq.{succ u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (Submonoid.map.{u1, u2, u3} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u2} N _inst_2 (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f m))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u3}} {F : Type.{u2}} [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) (m : M), Eq.{succ u3} (Submonoid.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (Submonoid.map.{u1, u3, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) m) _inst_2 (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u2, u1, u3} F M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3)) f m))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u3}} {F : Type.{u2}} [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) (m : M), Eq.{succ u3} (Submonoid.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (Submonoid.map.{u1, u3, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) m) _inst_2 (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2397 : M) => N) _x) (MulHomClass.toFunLike.{u2, u1, u3} F M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3)) f m))
 Case conversion may be inaccurate. Consider using '#align submonoid.map_powers Submonoid.map_powersₓ'. -/
 @[simp]
 theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :
@@ -1080,7 +1080,7 @@ section mul_add
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) (fun (_x : Equiv.{succ u1, succ u1} M (Additive.{u1} M)) => M -> (Additive.{u1} M)) (Equiv.hasCoeToFun.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (SetLike.Set.hasCoeT.{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 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1)))))) (AddSubmonoid.multiples.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) (fun (_x : Equiv.{succ u1, succ u1} M (Additive.{u1} M)) => M -> (Additive.{u1} M)) (Equiv.hasCoeToFun.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.instSetLikeAddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (AddSubmonoid.multiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.instSetLikeAddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (AddSubmonoid.multiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
 Case conversion may be inaccurate. Consider using '#align of_mul_image_powers_eq_multiples_of_mul ofMul_image_powers_eq_multiples_ofMulₓ'. -/
 theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
     Additive.ofMul '' (Submonoid.powers x : Set M) = AddSubmonoid.multiples (Additive.ofMul x) :=
@@ -1099,7 +1099,7 @@ theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
 lean 3 declaration is
   forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.setLike.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1))))) (AddSubmonoid.multiples.{u1} A _inst_1 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.setLike.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1)))))) (Submonoid.powers.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 but is expected to have type
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.multiples.{u1} A _inst_1 x))) (SetLike.coe.{u1, u1} (Submonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.instSetLikeSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Submonoid.powers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
+  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.multiples.{u1} A _inst_1 x))) (SetLike.coe.{u1, u1} (Submonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.instSetLikeSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Submonoid.powers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 Case conversion may be inaccurate. Consider using '#align of_add_image_multiples_eq_powers_of_add ofAdd_image_multiples_eq_powers_ofAddₓ'. -/
 theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
     Multiplicative.ofAdd '' (AddSubmonoid.multiples x : Set A) =

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

@@ -279,7 +279,7 @@ namespace Submonoid
 
 /- warning: submonoid.mem_supr_of_directed -> Submonoid.mem_iSup_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i))))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i))))
 Case conversion may be inaccurate. Consider using '#align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directedₓ'. -/
@@ -302,7 +302,7 @@ theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (
 
 /- warning: submonoid.coe_supr_of_directed -> Submonoid.coe_iSup_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Set.iUnion.{u1, u2} M ι (fun (i : ι) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (S i))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Set.iUnion.{u1, u2} M ι (fun (i : ι) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (S i))))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Set.iUnion.{u1, u2} M ι (fun (i : ι) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (S i))))
 Case conversion may be inaccurate. Consider using '#align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directedₓ'. -/
@@ -315,7 +315,7 @@ theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : D
 
 /- warning: submonoid.mem_Sup_of_directed_on -> Submonoid.mem_sSup_of_directedOn is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Exists.{0} (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Exists.{0} (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s))))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => And (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x s))))
 Case conversion may be inaccurate. Consider using '#align submonoid.mem_Sup_of_directed_on Submonoid.mem_sSup_of_directedOnₓ'. -/
@@ -330,7 +330,7 @@ theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
 
 /- warning: submonoid.coe_Sup_of_directed_on -> Submonoid.coe_sSup_of_directedOn is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Set.iUnion.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.iUnion.{u1, 0} M (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) s))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toHasLe.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Set.iUnion.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.iUnion.{u1, 0} M (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) s))))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Set.iUnion.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.iUnion.{u1, 0} M (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) s))))
 Case conversion may be inaccurate. Consider using '#align submonoid.coe_Sup_of_directed_on Submonoid.coe_sSup_of_directedOnₓ'. -/
@@ -696,7 +696,7 @@ theorem powers_eq_closure (n : M) : powers n = closure {n} :=
 
 /- warning: submonoid.powers_subset -> Submonoid.powers_subset is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {n : M} {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) n P) -> (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))))) (Submonoid.powers.{u1} M _inst_1 n) P)
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {n : M} {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) n P) -> (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))))) (Submonoid.powers.{u1} M _inst_1 n) P)
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {n : M} {P : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (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))) n P) -> (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)))))) (Submonoid.powers.{u1} M _inst_1 n) P)
 Case conversion may be inaccurate. Consider using '#align submonoid.powers_subset Submonoid.powers_subsetₓ'. -/

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

@@ -277,69 +277,69 @@ open Set
 
 namespace Submonoid
 
-/- warning: submonoid.mem_supr_of_directed -> Submonoid.mem_supᵢ_of_directed is a dubious translation:
+/- warning: submonoid.mem_supr_of_directed -> Submonoid.mem_iSup_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i))))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_supr_of_directed Submonoid.mem_supᵢ_of_directedₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [hι : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1220 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1222) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Exists.{u2} ι (fun (i : ι) => Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i))))
+Case conversion may be inaccurate. Consider using '#align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directedₓ'. -/
 -- TODO: this section can be generalized to `[submonoid_class B M] [complete_lattice B]`
 -- such that `complete_lattice.le` coincides with `set_like.le`
 @[to_additive]
-theorem mem_supᵢ_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S)
+theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S)
     {x : M} : (x ∈ ⨆ i, S i) ↔ ∃ i, x ∈ S i :=
   by
-  refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_supᵢ S i) hi⟩
+  refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_iSup S i) hi⟩
   suffices x ∈ closure (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
-    simpa only [closure_unionᵢ, closure_eq (S _)] using this
+    simpa only [closure_iUnion, closure_eq (S _)] using this
   refine' fun hx => closure_induction hx (fun _ => mem_Union.1) _ _
   · exact hι.elim fun i => ⟨i, (S i).one_mem⟩
   · rintro x y ⟨i, hi⟩ ⟨j, hj⟩
     rcases hS i j with ⟨k, hki, hkj⟩
     exact ⟨k, (S k).mul_mem (hki hi) (hkj hj)⟩
-#align submonoid.mem_supr_of_directed Submonoid.mem_supᵢ_of_directed
-#align add_submonoid.mem_supr_of_directed AddSubmonoid.mem_supᵢ_of_directed
+#align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directed
+#align add_submonoid.mem_supr_of_directed AddSubmonoid.mem_iSup_of_directed
 
-/- warning: submonoid.coe_supr_of_directed -> Submonoid.coe_supᵢ_of_directed is a dubious translation:
+/- warning: submonoid.coe_supr_of_directed -> Submonoid.coe_iSup_of_directed is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Set.unionᵢ.{u1, u2} M ι (fun (i : ι) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (S i))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (Set.iUnion.{u1, u2} M ι (fun (i : ι) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (S i))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Set.unionᵢ.{u1, u2} M ι (fun (i : ι) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (S i))))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_supr_of_directed Submonoid.coe_supᵢ_of_directedₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} [_inst_2 : Nonempty.{u2} ι] {S : ι -> (Submonoid.{u1} M _inst_1)}, (Directed.{u1, u2} (Submonoid.{u1} M _inst_1) ι (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1465 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1467) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (Set.iUnion.{u1, u2} M ι (fun (i : ι) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (S i))))
+Case conversion may be inaccurate. Consider using '#align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directedₓ'. -/
 @[to_additive]
-theorem coe_supᵢ_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S) :
+theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S) :
     ((⨆ i, S i : Submonoid M) : Set M) = ⋃ i, ↑(S i) :=
   Set.ext fun x => by simp [mem_supr_of_directed hS]
-#align submonoid.coe_supr_of_directed Submonoid.coe_supᵢ_of_directed
-#align add_submonoid.coe_supr_of_directed AddSubmonoid.coe_supᵢ_of_directed
+#align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directed
+#align add_submonoid.coe_supr_of_directed AddSubmonoid.coe_iSup_of_directed
 
-/- warning: submonoid.mem_Sup_of_directed_on -> Submonoid.mem_supₛ_of_directedOn is a dubious translation:
+/- warning: submonoid.mem_Sup_of_directed_on -> Submonoid.mem_sSup_of_directedOn is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.supₛ.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Exists.{0} (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (forall {x : M}, Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Exists.{0} (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (SupSet.supₛ.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => And (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x s))))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_Sup_of_directed_on Submonoid.mem_supₛ_of_directedOnₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1555 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1557) S) -> (forall {x : M}, Iff (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Exists.{succ u1} (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => And (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x s))))
+Case conversion may be inaccurate. Consider using '#align submonoid.mem_Sup_of_directed_on Submonoid.mem_sSup_of_directedOnₓ'. -/
 @[to_additive]
-theorem mem_supₛ_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
-    (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ supₛ S ↔ ∃ s ∈ S, x ∈ s :=
+theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
+    (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s :=
   by
   haveI : Nonempty S := Sne.to_subtype
-  simp only [supₛ_eq_supᵢ', mem_supr_of_directed hS.directed_coe, SetCoe.exists, Subtype.coe_mk]
-#align submonoid.mem_Sup_of_directed_on Submonoid.mem_supₛ_of_directedOn
-#align add_submonoid.mem_Sup_of_directed_on AddSubmonoid.mem_supₛ_of_directedOn
+  simp only [sSup_eq_iSup', mem_supr_of_directed hS.directed_coe, SetCoe.exists, Subtype.coe_mk]
+#align submonoid.mem_Sup_of_directed_on Submonoid.mem_sSup_of_directedOn
+#align add_submonoid.mem_Sup_of_directed_on AddSubmonoid.mem_sSup_of_directedOn
 
-/- warning: submonoid.coe_Sup_of_directed_on -> Submonoid.coe_supₛ_of_directedOn is a dubious translation:
+/- warning: submonoid.coe_Sup_of_directed_on -> Submonoid.coe_sSup_of_directedOn is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (SupSet.supₛ.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Set.unionᵢ.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.unionᵢ.{u1, 0} M (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) s))))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1))))) S) -> (Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)) (Set.iUnion.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.iUnion.{u1, 0} M (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) => (fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M _inst_1) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M _inst_1) (Set.{u1} M) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)))) s))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SupSet.supₛ.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Set.unionᵢ.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.unionᵢ.{u1, 0} M (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) s))))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_Sup_of_directed_on Submonoid.coe_supₛ_of_directedOnₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)}, (Set.Nonempty.{u1} (Submonoid.{u1} M _inst_1) S) -> (DirectedOn.{u1} (Submonoid.{u1} M _inst_1) (fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 : Submonoid.{u1} M _inst_1) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647 : Submonoid.{u1} M _inst_1) => LE.le.{u1} (Submonoid.{u1} M _inst_1) (Preorder.toLE.{u1} (Submonoid.{u1} M _inst_1) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1))))) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1645 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.1647) S) -> (Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)) (Set.iUnion.{u1, succ u1} M (Submonoid.{u1} M _inst_1) (fun (s : Submonoid.{u1} M _inst_1) => Set.iUnion.{u1, 0} M (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) (fun (H : Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) => SetLike.coe.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) s))))
+Case conversion may be inaccurate. Consider using '#align submonoid.coe_Sup_of_directed_on Submonoid.coe_sSup_of_directedOnₓ'. -/
 @[to_additive]
-theorem coe_supₛ_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
-    (hS : DirectedOn (· ≤ ·) S) : (↑(supₛ S) : Set M) = ⋃ s ∈ S, ↑s :=
+theorem coe_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
+    (hS : DirectedOn (· ≤ ·) S) : (↑(sSup S) : Set M) = ⋃ s ∈ S, ↑s :=
   Set.ext fun x => by simp [mem_Sup_of_directed_on Sne hS]
-#align submonoid.coe_Sup_of_directed_on Submonoid.coe_supₛ_of_directedOn
-#align add_submonoid.coe_Sup_of_directed_on AddSubmonoid.coe_supₛ_of_directedOn
+#align submonoid.coe_Sup_of_directed_on Submonoid.coe_sSup_of_directedOn
+#align add_submonoid.coe_Sup_of_directed_on AddSubmonoid.coe_sSup_of_directedOn
 
 /- warning: submonoid.mem_sup_left -> Submonoid.mem_sup_left is a dubious translation:
 lean 3 declaration is
@@ -377,64 +377,64 @@ theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T)
 #align submonoid.mul_mem_sup Submonoid.mul_mem_sup
 #align add_submonoid.add_mem_sup AddSubmonoid.add_mem_sup
 
-/- warning: submonoid.mem_supr_of_mem -> Submonoid.mem_supᵢ_of_mem is a dubious translation:
+/- warning: submonoid.mem_supr_of_mem -> Submonoid.mem_iSup_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} {S : ι -> (Submonoid.{u1} M _inst_1)} (i : ι) {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι S))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} {S : ι -> (Submonoid.{u1} M _inst_1)} (i : ι) {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι S))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} {S : ι -> (Submonoid.{u1} M _inst_1)} (i : ι) {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι S))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_supr_of_mem Submonoid.mem_supᵢ_of_memₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} {S : ι -> (Submonoid.{u1} M _inst_1)} (i : ι) {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι S))
+Case conversion may be inaccurate. Consider using '#align submonoid.mem_supr_of_mem Submonoid.mem_iSup_of_memₓ'. -/
 @[to_additive]
-theorem mem_supᵢ_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
-    ∀ {x : M}, x ∈ S i → x ∈ supᵢ S :=
-  show S i ≤ supᵢ S from le_supᵢ _ _
-#align submonoid.mem_supr_of_mem Submonoid.mem_supᵢ_of_mem
-#align add_submonoid.mem_supr_of_mem AddSubmonoid.mem_supᵢ_of_mem
+theorem mem_iSup_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
+    ∀ {x : M}, x ∈ S i → x ∈ iSup S :=
+  show S i ≤ iSup S from le_iSup _ _
+#align submonoid.mem_supr_of_mem Submonoid.mem_iSup_of_mem
+#align add_submonoid.mem_supr_of_mem AddSubmonoid.mem_iSup_of_mem
 
-/- warning: submonoid.mem_Sup_of_mem -> Submonoid.mem_supₛ_of_mem is a dubious translation:
+/- warning: submonoid.mem_Sup_of_mem -> Submonoid.mem_sSup_of_mem is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)} {s : Submonoid.{u1} M _inst_1}, (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.supₛ.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)} {s : Submonoid.{u1} M _inst_1}, (Membership.Mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.hasMem.{u1} (Submonoid.{u1} M _inst_1)) s S) -> (forall {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x s) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) S)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)} {s : Submonoid.{u1} M _inst_1}, (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) -> (forall {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x s) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (SupSet.supₛ.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_Sup_of_mem Submonoid.mem_supₛ_of_memₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Set.{u1} (Submonoid.{u1} M _inst_1)} {s : Submonoid.{u1} M _inst_1}, (Membership.mem.{u1, u1} (Submonoid.{u1} M _inst_1) (Set.{u1} (Submonoid.{u1} M _inst_1)) (Set.instMembershipSet.{u1} (Submonoid.{u1} M _inst_1)) s S) -> (forall {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x s) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (SupSet.sSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) S)))
+Case conversion may be inaccurate. Consider using '#align submonoid.mem_Sup_of_mem Submonoid.mem_sSup_of_memₓ'. -/
 @[to_additive]
-theorem mem_supₛ_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
-    ∀ {x : M}, x ∈ s → x ∈ supₛ S :=
-  show s ≤ supₛ S from le_supₛ hs
-#align submonoid.mem_Sup_of_mem Submonoid.mem_supₛ_of_mem
-#align add_submonoid.mem_Sup_of_mem AddSubmonoid.mem_supₛ_of_mem
+theorem mem_sSup_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
+    ∀ {x : M}, x ∈ s → x ∈ sSup S :=
+  show s ≤ sSup S from le_sSup hs
+#align submonoid.mem_Sup_of_mem Submonoid.mem_sSup_of_mem
+#align add_submonoid.mem_Sup_of_mem AddSubmonoid.mem_sSup_of_mem
 
-/- warning: submonoid.supr_induction -> Submonoid.supᵢ_induction is a dubious translation:
+/- warning: submonoid.supr_induction -> Submonoid.iSup_induction is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : M -> Prop} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) -> (forall (i : ι) (x : M), (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)) -> (C x)) -> (C (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_1))))) -> (forall (x : M) (y : M), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y))) -> (C x)
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : M -> Prop} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) -> (forall (i : ι) (x : M), (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)) -> (C x)) -> (C (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_1))))) -> (forall (x : M) (y : M), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y))) -> (C x)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : M -> Prop} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) -> (forall (i : ι) (x : M), (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)) -> (C x)) -> (C (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (MulOneClass.toOne.{u1} M _inst_1)))) -> (forall (x : M) (y : M), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y))) -> (C x)
-Case conversion may be inaccurate. Consider using '#align submonoid.supr_induction Submonoid.supᵢ_inductionₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : M -> Prop} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) -> (forall (i : ι) (x : M), (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)) -> (C x)) -> (C (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (MulOneClass.toOne.{u1} M _inst_1)))) -> (forall (x : M) (y : M), (C x) -> (C y) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y))) -> (C x)
+Case conversion may be inaccurate. Consider using '#align submonoid.supr_induction Submonoid.iSup_inductionₓ'. -/
 /-- An induction principle for elements of `⨆ i, S i`.
 If `C` holds for `1` and all elements of `S i` for all `i`, and is preserved under multiplication,
 then it holds for all elements of the supremum of `S`. -/
 @[elab_as_elim,
   to_additive
       " An induction principle for elements of `⨆ i, S i`.\nIf `C` holds for `0` and all elements of `S i` for all `i`, and is preserved under addition,\nthen it holds for all elements of the supremum of `S`. "]
-theorem supᵢ_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
+theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
     (hp : ∀ (i), ∀ x ∈ S i, C x) (h1 : C 1) (hmul : ∀ x y, C x → C y → C (x * y)) : C x :=
   by
   rw [supr_eq_closure] at hx
   refine' closure_induction hx (fun x hx => _) h1 hmul
   obtain ⟨i, hi⟩ := set.mem_Union.mp hx
   exact hp _ _ hi
-#align submonoid.supr_induction Submonoid.supᵢ_induction
-#align add_submonoid.supr_induction AddSubmonoid.supᵢ_induction
+#align submonoid.supr_induction Submonoid.iSup_induction
+#align add_submonoid.supr_induction AddSubmonoid.iSup_induction
 
-/- warning: submonoid.supr_induction' -> Submonoid.supᵢ_induction' is a dubious translation:
+/- warning: submonoid.supr_induction' -> Submonoid.iSup_induction' is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : forall (x : M), (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) -> Prop}, (forall (i : ι) (x : M) (H : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)), C x (Submonoid.mem_supᵢ_of_mem.{u1, u2} M _inst_1 ι (fun (i : ι) => S i) i x H)) -> (C (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_1)))) (OneMemClass.one_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toHasOne.{u1} M _inst_1) (Submonoid.setLike.{u1} M _inst_1) (SubmonoidClass.to_oneMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.setLike.{u1} M _inst_1) (Submonoid.submonoidClass.{u1} M _inst_1)) (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i)))) -> (forall (x : M) (y : M) (hx : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (hy : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) y (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))), (C x hx) -> (C y hy) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y) (MulMemClass.mul_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toHasMul.{u1} M _inst_1) (Submonoid.setLike.{u1} M _inst_1) (SubmonoidClass.to_mulMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.setLike.{u1} M _inst_1) (Submonoid.submonoidClass.{u1} M _inst_1)) (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i)) x y hx hy))) -> (forall {x : M} (hx : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))), C x hx)
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : forall (x : M), (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) -> Prop}, (forall (i : ι) (x : M) (H : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (S i)), C x (Submonoid.mem_iSup_of_mem.{u1, u2} M _inst_1 ι (fun (i : ι) => S i) i x H)) -> (C (OfNat.ofNat.{u1} M 1 (OfNat.mk.{u1} M 1 (One.one.{u1} M (MulOneClass.toHasOne.{u1} M _inst_1)))) (OneMemClass.one_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toHasOne.{u1} M _inst_1) (Submonoid.setLike.{u1} M _inst_1) (SubmonoidClass.to_oneMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.setLike.{u1} M _inst_1) (Submonoid.submonoidClass.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i)))) -> (forall (x : M) (y : M) (hx : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))) (hy : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) y (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))), (C x hx) -> (C y hy) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y) (MulMemClass.mul_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toHasMul.{u1} M _inst_1) (Submonoid.setLike.{u1} M _inst_1) (SubmonoidClass.to_mulMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.setLike.{u1} M _inst_1) (Submonoid.submonoidClass.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i)) x y hx hy))) -> (forall {x : M} (hx : Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteSemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toCompleteSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1))) ι (fun (i : ι) => S i))), C x hx)
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : forall (x : M), (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) -> Prop}, (forall (i : ι) (x : M) (H : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)), C x (Submonoid.mem_supᵢ_of_mem.{u1, u2} M _inst_1 ι (fun (i : ι) => S i) i x H)) -> (C (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (MulOneClass.toOne.{u1} M _inst_1))) (OneMemClass.one_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toOne.{u1} M _inst_1) (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SubmonoidClass.toOneMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (Submonoid.instSubmonoidClassSubmonoidInstSetLikeSubmonoid.{u1} M _inst_1)) (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i)))) -> (forall (x : M) (y : M) (hx : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (hy : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) y (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))), (C x hx) -> (C y hy) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y) (MulMemClass.mul_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toMul.{u1} M _inst_1) (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SubmonoidClass.toMulMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (Submonoid.instSubmonoidClassSubmonoidInstSetLikeSubmonoid.{u1} M _inst_1)) (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i)) x y hx hy))) -> (forall {x : M} (hx : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (supᵢ.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))), C x hx)
-Case conversion may be inaccurate. Consider using '#align submonoid.supr_induction' Submonoid.supᵢ_induction'ₓ'. -/
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} M _inst_1)) {C : forall (x : M), (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) -> Prop}, (forall (i : ι) (x : M) (H : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (S i)), C x (Submonoid.mem_iSup_of_mem.{u1, u2} M _inst_1 ι (fun (i : ι) => S i) i x H)) -> (C (OfNat.ofNat.{u1} M 1 (One.toOfNat1.{u1} M (MulOneClass.toOne.{u1} M _inst_1))) (OneMemClass.one_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toOne.{u1} M _inst_1) (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SubmonoidClass.toOneMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (Submonoid.instSubmonoidClassSubmonoidInstSetLikeSubmonoid.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i)))) -> (forall (x : M) (y : M) (hx : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))) (hy : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) y (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))), (C x hx) -> (C y hy) -> (C (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y) (MulMemClass.mul_mem.{u1, u1} (Submonoid.{u1} M _inst_1) M (MulOneClass.toMul.{u1} M _inst_1) (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (SubmonoidClass.toMulMemClass.{u1, u1} (Submonoid.{u1} M _inst_1) M _inst_1 (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1) (Submonoid.instSubmonoidClassSubmonoidInstSetLikeSubmonoid.{u1} M _inst_1)) (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i)) x y hx hy))) -> (forall {x : M} (hx : Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (iSup.{u1, u2} (Submonoid.{u1} M _inst_1) (CompleteLattice.toSupSet.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)) ι (fun (i : ι) => S i))), C x hx)
+Case conversion may be inaccurate. Consider using '#align submonoid.supr_induction' Submonoid.iSup_induction'ₓ'. -/
 /-- A dependent version of `submonoid.supr_induction`. -/
 @[elab_as_elim, to_additive "A dependent version of `add_submonoid.supr_induction`. "]
-theorem supᵢ_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
-    (hp : ∀ (i), ∀ x ∈ S i, C x (mem_supᵢ_of_mem i ‹_›)) (h1 : C 1 (one_mem _))
+theorem iSup_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
+    (hp : ∀ (i), ∀ x ∈ S i, C x (mem_iSup_of_mem i ‹_›)) (h1 : C 1 (one_mem _))
     (hmul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (mul_mem ‹_› ‹_›)) {x : M}
     (hx : x ∈ ⨆ i, S i) : C x hx :=
   by
@@ -444,8 +444,8 @@ theorem supᵢ_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x
   · exact ⟨_, h1⟩
   · rintro ⟨_, Cx⟩ ⟨_, Cy⟩
     refine' ⟨_, hmul _ _ _ _ Cx Cy⟩
-#align submonoid.supr_induction' Submonoid.supᵢ_induction'
-#align add_submonoid.supr_induction' AddSubmonoid.supᵢ_induction'
+#align submonoid.supr_induction' Submonoid.iSup_induction'
+#align add_submonoid.supr_induction' AddSubmonoid.iSup_induction'
 
 end Submonoid
 

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

@@ -665,6 +665,12 @@ theorem mem_powers (n : M) : n ∈ powers n :=
   ⟨1, pow_one _⟩
 #align submonoid.mem_powers Submonoid.mem_powers
 
+/- warning: submonoid.coe_powers -> Submonoid.coe_powers is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : M), Eq.{succ u1} (Set.{u1} M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (SetLike.Set.hasCoeT.{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 x)) (Set.range.{u1, 1} M Nat (fun (n : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x n))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : M), Eq.{succ u1} (Set.{u1} M) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 x)) (Set.range.{u1, 1} M Nat (fun (n : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x n))
+Case conversion may be inaccurate. Consider using '#align submonoid.coe_powers Submonoid.coe_powersₓ'. -/
 @[norm_cast]
 theorem coe_powers (x : M) : ↑(powers x) = Set.range fun n : ℕ => x ^ n :=
   rfl

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

@@ -5,7 +5,7 @@ Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzza
 Amelia Livingston, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module group_theory.submonoid.membership
-! leanprover-community/mathlib commit 2ec920d35348cb2d13ac0e1a2ad9df0fdf1a76b4
+! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -665,6 +665,11 @@ theorem mem_powers (n : M) : n ∈ powers n :=
   ⟨1, pow_one _⟩
 #align submonoid.mem_powers Submonoid.mem_powers
 
+@[norm_cast]
+theorem coe_powers (x : M) : ↑(powers x) = Set.range fun n : ℕ => x ^ n :=
+  rfl
+#align submonoid.coe_powers Submonoid.coe_powers
+
 /- warning: submonoid.mem_powers_iff -> Submonoid.mem_powers_iff is a dubious translation:
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (x : M) (z : M), Iff (Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.powers.{u1} M _inst_1 z)) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) z n) x))
@@ -964,6 +969,8 @@ attribute [to_additive multiples] Submonoid.powers
 
 attribute [to_additive mem_multiples] Submonoid.mem_powers
 
+attribute [to_additive coe_multiples] Submonoid.coe_powers
+
 attribute [to_additive mem_multiples_iff] Submonoid.mem_powers_iff
 
 attribute [to_additive multiples_eq_closure] Submonoid.powers_eq_closure

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

@@ -5,7 +5,7 @@ Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzza
 Amelia Livingston, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module group_theory.submonoid.membership
-! leanprover-community/mathlib commit 327c3c0d9232d80e250dc8f65e7835b82b266ea5
+! leanprover-community/mathlib commit 2ec920d35348cb2d13ac0e1a2ad9df0fdf1a76b4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -546,7 +546,7 @@ Case conversion may be inaccurate. Consider using '#align submonoid.closure_eq_i
 theorem closure_eq_image_prod (s : Set M) :
     (closure s : Set M) = List.prod '' { l : List M | ∀ x ∈ l, x ∈ s } :=
   by
-  rw [closure_eq_mrange, coe_mrange, ← List.range_map_coe, ← Set.range_comp, Function.comp]
+  rw [closure_eq_mrange, coe_mrange, ← Set.range_list_map_coe, ← Set.range_comp]
   exact congr_arg _ (funext <| FreeMonoid.lift_apply _)
 #align submonoid.closure_eq_image_prod Submonoid.closure_eq_image_prod
 #align add_submonoid.closure_eq_image_sum AddSubmonoid.closure_eq_image_sum

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

@@ -721,7 +721,7 @@ def pow (n : M) (m : ℕ) : powers n :=
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M) (m : Nat), Eq.{succ 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 n)) (Submonoid.pow.{u1} M _inst_1 n m) (Subtype.mk.{succ u1} M (fun (x : M) => Membership.Mem.{u1, u1} M (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.setLike.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) x (Submonoid.powers.{u1} M _inst_1 n)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m) (Exists.intro.{1} Nat (fun (y : Nat) => Eq.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n y) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) m (rfl.{succ u1} M (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m))))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M) (m : Nat), Eq.{succ 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 n))) (Submonoid.pow.{u1} M _inst_1 n m) (Subtype.mk.{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 n)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m) (Exists.intro.{1} Nat (fun (y : Nat) => Eq.{succ u1} M ((fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3541 : M) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3543 : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3541 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3543) n y) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) m (rfl.{succ u1} M ((fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3541 : M) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3543 : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3541 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3543) n m))))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (n : M) (m : Nat), Eq.{succ 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 n))) (Submonoid.pow.{u1} M _inst_1 n m) (Subtype.mk.{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 n)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m) (Exists.intro.{1} Nat (fun (y : Nat) => Eq.{succ u1} M ((fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 : M) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548 : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548) n y) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) n m)) m (rfl.{succ u1} M ((fun (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 : M) (x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548 : Nat) => HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3546 x._@.Mathlib.GroupTheory.Submonoid.Membership._hyg.3548) n m))))
 Case conversion may be inaccurate. Consider using '#align submonoid.pow_apply Submonoid.pow_applyₓ'. -/
 theorem pow_apply (n : M) (m : ℕ) : Submonoid.pow n m = ⟨n ^ m, m, rfl⟩ :=
   rfl
@@ -811,7 +811,7 @@ theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u2}} {F : Type.{u3}} [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (m : M), Eq.{succ u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (Submonoid.map.{u1, u2, u3} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u2} N _inst_2 (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f m))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u3}} {F : Type.{u2}} [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) (m : M), Eq.{succ u3} (Submonoid.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (Submonoid.map.{u1, u3, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) m) _inst_2 (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u2, u1, u3} F M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3)) f m))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u3}} {F : Type.{u2}} [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) (m : M), Eq.{succ u3} (Submonoid.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (Submonoid.map.{u1, u3, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) m) _inst_2 (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2391 : M) => N) _x) (MulHomClass.toFunLike.{u2, u1, u3} F M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3)) f m))
 Case conversion may be inaccurate. Consider using '#align submonoid.map_powers Submonoid.map_powersₓ'. -/
 @[simp]
 theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :
@@ -1067,7 +1067,7 @@ section mul_add
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) (fun (_x : Equiv.{succ u1, succ u1} M (Additive.{u1} M)) => M -> (Additive.{u1} M)) (Equiv.hasCoeToFun.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Set.{u1} M) (SetLike.Set.hasCoeT.{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 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Set.{u1} (Additive.{u1} M)) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.setLike.{u1} (Additive.{u1} M) (AddMonoid.toAddZeroClass.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1)))))) (AddSubmonoid.multiples.{u1} (Additive.{u1} M) (Additive.addMonoid.{u1} M _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) (fun (_x : Equiv.{succ u1, succ u1} M (Additive.{u1} M)) => M -> (Additive.{u1} M)) (Equiv.hasCoeToFun.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.instSetLikeAddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (AddSubmonoid.multiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {x : M}, Eq.{succ u1} (Set.{u1} (Additive.{u1} M)) (Set.image.{u1, u1} M (Additive.{u1} M) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M)) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.powers.{u1} M _inst_1 x))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (Additive.{u1} M) (AddSubmonoid.instSetLikeAddSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (AddMonoid.toAddZeroClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1))) (AddSubmonoid.multiples.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) x) (Additive.addMonoid.{u1} M _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} M (Additive.{u1} M)) M (fun (_x : M) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : M) => Additive.{u1} M) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} M (Additive.{u1} M)) (Additive.ofMul.{u1} M) x)))
 Case conversion may be inaccurate. Consider using '#align of_mul_image_powers_eq_multiples_of_mul ofMul_image_powers_eq_multiples_ofMulₓ'. -/
 theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
     Additive.ofMul '' (Submonoid.powers x : Set M) = AddSubmonoid.multiples (Additive.ofMul x) :=
@@ -1086,7 +1086,7 @@ theorem ofMul_image_powers_eq_multiples_ofMul [Monoid M] {x : M} :
 lean 3 declaration is
   forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (Set.{u1} A) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.setLike.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1))))) (AddSubmonoid.multiples.{u1} A _inst_1 x))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Set.{u1} (Multiplicative.{u1} A)) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.setLike.{u1} (Multiplicative.{u1} A) (Monoid.toMulOneClass.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1)))))) (Submonoid.powers.{u1} (Multiplicative.{u1} A) (Multiplicative.monoid.{u1} A _inst_1) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (fun (_x : Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) => A -> (Multiplicative.{u1} A)) (Equiv.hasCoeToFun.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 but is expected to have type
-  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.multiples.{u1} A _inst_1 x))) (SetLike.coe.{u1, u1} (Submonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.instSetLikeSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Submonoid.powers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
+  forall {A : Type.{u1}} [_inst_1 : AddMonoid.{u1} A] {x : A}, Eq.{succ u1} (Set.{u1} (Multiplicative.{u1} A)) (Set.image.{u1, u1} A (Multiplicative.{u1} A) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A)) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_1)) (AddSubmonoid.multiples.{u1} A _inst_1 x))) (SetLike.coe.{u1, u1} (Submonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Multiplicative.{u1} A) (Submonoid.instSetLikeSubmonoid.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Monoid.toMulOneClass.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1))) (Submonoid.powers.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) x) (Multiplicative.monoid.{u1} A _inst_1) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) A (fun (_x : A) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : A) => Multiplicative.{u1} A) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} A (Multiplicative.{u1} A)) (Multiplicative.ofAdd.{u1} A) x)))
 Case conversion may be inaccurate. Consider using '#align of_add_image_multiples_eq_powers_of_add ofAdd_image_multiples_eq_powers_ofAddₓ'. -/
 theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
     Multiplicative.ofAdd '' (AddSubmonoid.multiples x : Set A) =

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

@@ -996,7 +996,9 @@ theorem mul_right_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
   revert b
   refine' AddSubmonoid.closure_induction ha _ _ _ <;> clear ha a
   · exact fun r hr b hb => add_submonoid.mem_closure.mpr fun y hy => hy (mul_mem hr hb)
-  · exact fun b hb => by simp only [zero_mul, (AddSubmonoid.closure (S : Set R)).zero_mem]
+  ·
+    exact fun b hb => by
+      simp only [MulZeroClass.zero_mul, (AddSubmonoid.closure (S : Set R)).zero_mem]
   · simp_rw [add_mul]
     exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr hb) (hs hb)
 #align mul_mem_class.mul_right_mem_add_closure MulMemClass.mul_right_mem_add_closure
@@ -1015,7 +1017,9 @@ theorem mul_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
   revert a
   refine' AddSubmonoid.closure_induction hb _ _ _ <;> clear hb b
   · exact fun r hr b hb => MulMemClass.mul_right_mem_add_closure hb hr
-  · exact fun b hb => by simp only [mul_zero, (AddSubmonoid.closure (S : Set R)).zero_mem]
+  ·
+    exact fun b hb => by
+      simp only [MulZeroClass.mul_zero, (AddSubmonoid.closure (S : Set R)).zero_mem]
   · simp_rw [mul_add]
     exact fun r s hr hs b hb => (AddSubmonoid.closure (S : Set R)).add_mem (hr hb) (hs hb)
 #align mul_mem_class.mul_mem_add_closure MulMemClass.mul_mem_add_closure

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

@@ -811,7 +811,7 @@ theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x
 lean 3 declaration is
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u2}} {F : Type.{u3}} [_inst_2 : Monoid.{u2} N] [_inst_3 : MonoidHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2)] (f : F) (m : M), Eq.{succ u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (Submonoid.map.{u1, u2, u3} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u2} N _inst_2 (coeFn.{succ u3, max (succ u1) (succ u2)} F (fun (_x : F) => M -> N) (FunLike.hasCoeToFun.{succ u3, succ u1, succ u2} F M (fun (_x : M) => N) (MulHomClass.toFunLike.{u3, u1, u2} F M N (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N _inst_2)) (MonoidHomClass.toMulHomClass.{u3, u1, u2} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u2} N _inst_2) _inst_3))) f m))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u3}} {F : Type.{u2}} [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) (m : M), Eq.{succ u3} (Submonoid.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (Submonoid.map.{u1, u3, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) m) _inst_2 (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2398 : M) => N) _x) (MulHomClass.toFunLike.{u2, u1, u3} F M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3)) f m))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u3}} {F : Type.{u2}} [_inst_2 : Monoid.{u3} N] [_inst_3 : MonoidHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2)] (f : F) (m : M), Eq.{succ u3} (Submonoid.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (Submonoid.map.{u1, u3, u2} M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) F _inst_3 f (Submonoid.powers.{u1} M _inst_1 m)) (Submonoid.powers.{u3} ((fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) m) _inst_2 (FunLike.coe.{succ u2, succ u1, succ u3} F M (fun (_x : M) => (fun (x._@.Mathlib.Algebra.Hom.Group._hyg.2372 : M) => N) _x) (MulHomClass.toFunLike.{u2, u1, u3} F M N (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOneClass.toMul.{u3} N (Monoid.toMulOneClass.{u3} N _inst_2)) (MonoidHomClass.toMulHomClass.{u2, u1, u3} F M N (Monoid.toMulOneClass.{u1} M _inst_1) (Monoid.toMulOneClass.{u3} N _inst_2) _inst_3)) f m))
 Case conversion may be inaccurate. Consider using '#align submonoid.map_powers Submonoid.map_powersₓ'. -/
 @[simp]
 theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :

mathlib commit https://github.com/leanprover-community/mathlib/commit/4c586d291f189eecb9d00581aeb3dd998ac34442

@@ -825,7 +825,7 @@ lean 3 declaration is
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M}, (forall (a : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a s) -> (forall (b : M), (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b s) -> (Eq.{succ u1} M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) a b) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1))) b a)))) -> (CommMonoid.{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))))
 Case conversion may be inaccurate. Consider using '#align submonoid.closure_comm_monoid_of_comm Submonoid.closureCommMonoidOfCommₓ'. -/
-/- ./././Mathport/Syntax/Translate/Basic.lean:628:2: warning: expanding binder collection (a b «expr ∈ » s) -/
+/- ./././Mathport/Syntax/Translate/Basic.lean:635:2: warning: expanding binder collection (a b «expr ∈ » s) -/
 /-- If all the elements of a set `s` commute, then `closure s` is a commutative monoid. -/
 @[to_additive
       "If all the elements of a set `s` commute, then `closure s` forms an additive\ncommutative monoid."]

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

@@ -343,9 +343,9 @@ theorem coe_supₛ_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
 
 /- warning: submonoid.mem_sup_left -> Submonoid.mem_sup_left is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x S) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (HasSup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x S) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x S) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (HasSup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x S) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
 Case conversion may be inaccurate. Consider using '#align submonoid.mem_sup_left Submonoid.mem_sup_leftₓ'. -/
 @[to_additive]
 theorem mem_sup_left {S T : Submonoid M} : ∀ {x : M}, x ∈ S → x ∈ S ⊔ T :=
@@ -355,9 +355,9 @@ theorem mem_sup_left {S T : Submonoid M} : ∀ {x : M}, x ∈ S → x ∈ S ⊔
 
 /- warning: submonoid.mem_sup_right -> Submonoid.mem_sup_right is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x T) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (HasSup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x T) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x T) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (HasSup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x T) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
 Case conversion may be inaccurate. Consider using '#align submonoid.mem_sup_right Submonoid.mem_sup_rightₓ'. -/
 @[to_additive]
 theorem mem_sup_right {S T : Submonoid M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔ T :=
@@ -367,9 +367,9 @@ theorem mem_sup_right {S T : Submonoid M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔
 
 /- warning: submonoid.mul_mem_sup -> Submonoid.mul_mem_sup is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M} {y : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x S) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) y T) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y) (HasSup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M} {y : M}, (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) x S) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) y T) -> (Membership.Mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.setLike.{u1} M _inst_1)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toHasMul.{u1} M _inst_1)) x y) (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.completeLattice.{u1} M _inst_1)))) S T))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M} {y : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x S) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) y T) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y) (HasSup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
+  forall {M : Type.{u1}} [_inst_1 : MulOneClass.{u1} M] {S : Submonoid.{u1} M _inst_1} {T : Submonoid.{u1} M _inst_1} {x : M} {y : M}, (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) x S) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) y T) -> (Membership.mem.{u1, u1} M (Submonoid.{u1} M _inst_1) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} M _inst_1) M (Submonoid.instSetLikeSubmonoid.{u1} M _inst_1)) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M (MulOneClass.toMul.{u1} M _inst_1)) x y) (Sup.sup.{u1} (Submonoid.{u1} M _inst_1) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M _inst_1) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M _inst_1) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} M _inst_1) (Submonoid.instCompleteLatticeSubmonoid.{u1} M _inst_1)))) S T))
 Case conversion may be inaccurate. Consider using '#align submonoid.mul_mem_sup Submonoid.mul_mem_supₓ'. -/
 @[to_additive]
 theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T) : x * y ∈ S ⊔ T :=
@@ -891,9 +891,9 @@ open MonoidHom
 
 /- warning: submonoid.sup_eq_range -> Submonoid.sup_eq_range is a dubious translation:
 lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] (s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))), Eq.{succ u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (HasSup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.completeLattice.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t) (MonoidHom.mrange.{u1, u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) (MonoidHom.{u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.coprod.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) N (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t) _inst_1 (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)))
+  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] (s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))), Eq.{succ u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.completeLattice.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t) (MonoidHom.mrange.{u1, u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) (MonoidHom.{u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Prod.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t)) N (Prod.mulOneClass.{u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.coprod.{u1, u1, u1} (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) s) (coeSort.{succ u1, succ (succ u1)} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) Type.{u1} (SetLike.hasCoeToSort.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) t) N (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t) _inst_1 (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)))
 but is expected to have type
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] (s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))), Eq.{succ u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (HasSup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t) (MonoidHom.mrange.{u1, u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) (MonoidHom.{u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.coprod.{u1, u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) N (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t) _inst_1 (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)))
+  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] (s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))), Eq.{succ u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t) (MonoidHom.mrange.{u1, u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) (MonoidHom.{u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.monoidHomClass.{u1, u1} (Prod.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t))) N (Prod.instMulOneClassProd.{u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)) (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (MonoidHom.coprod.{u1, u1, u1} (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x s)) (Subtype.{succ u1} N (fun (x : N) => Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x t)) N (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.toMulOneClass.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t) _inst_1 (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) s) (Submonoid.subtype.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)) t)))
 Case conversion may be inaccurate. Consider using '#align submonoid.sup_eq_range Submonoid.sup_eq_rangeₓ'. -/
 @[to_additive]
 theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = (s.Subtype.coprod t.Subtype).mrange := by
@@ -904,9 +904,9 @@ theorem sup_eq_range (s t : Submonoid N) : s ⊔ t = (s.Subtype.coprod t.Subtype
 
 /- warning: submonoid.mem_sup -> Submonoid.mem_sup is a dubious translation:
 lean 3 declaration is
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] {s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {x : N}, Iff (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x (HasSup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.completeLattice.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t)) (Exists.{succ u1} N (fun (y : N) => Exists.{0} (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) (fun (H : Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) => Exists.{succ u1} N (fun (z : N) => Exists.{0} (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) (fun (H : Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) => Eq.{succ u1} N (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toHasMul.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y z) x)))))
+  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] {s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {x : N}, Iff (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.completeLattice.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t)) (Exists.{succ u1} N (fun (y : N) => Exists.{0} (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) (fun (H : Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) => Exists.{succ u1} N (fun (z : N) => Exists.{0} (Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) (fun (H : Membership.Mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.setLike.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) => Eq.{succ u1} N (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toHasMul.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y z) x)))))
 but is expected to have type
-  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] {s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {x : N}, Iff (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x (HasSup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t)) (Exists.{succ u1} N (fun (y : N) => And (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) (Exists.{succ u1} N (fun (z : N) => And (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) (Eq.{succ u1} N (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y z) x)))))
+  forall {N : Type.{u1}} [_inst_1 : CommMonoid.{u1} N] {s : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {t : Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))} {x : N}, Iff (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) x (Sup.sup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (CompleteLattice.toLattice.{u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (Submonoid.instCompleteLatticeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))))) s t)) (Exists.{succ u1} N (fun (y : N) => And (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y s) (Exists.{succ u1} N (fun (z : N) => And (Membership.mem.{u1, u1} N (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1))) N (Submonoid.instSetLikeSubmonoid.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) z t) (Eq.{succ u1} N (HMul.hMul.{u1, u1, u1} N N N (instHMul.{u1} N (MulOneClass.toMul.{u1} N (Monoid.toMulOneClass.{u1} N (CommMonoid.toMonoid.{u1} N _inst_1)))) y z) x)))))
 Case conversion may be inaccurate. Consider using '#align submonoid.mem_sup Submonoid.mem_supₓ'. -/
 @[to_additive]
 theorem mem_sup {s t : Submonoid N} {x : N} : x ∈ s ⊔ t ↔ ∃ y ∈ s, ∃ z ∈ t, y * z = x := by

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

Reduce the diff of #11499

Renames

All in the Int namespace:

• ofNat_eq_cast → ofNat_eq_natCast
• cast_eq_cast_iff_Nat → natCast_inj
• natCast_eq_ofNat → ofNat_eq_natCast
• coe_nat_sub → natCast_sub
• coe_nat_nonneg → natCast_nonneg
• sign_coe_add_one → sign_natCast_add_one
• nat_succ_eq_int_succ → natCast_succ
• succ_neg_nat_succ → succ_neg_natCast_succ
• coe_pred_of_pos → natCast_pred_of_pos
• coe_nat_div → natCast_div
• coe_nat_ediv → natCast_ediv
• sign_coe_nat_of_nonzero → sign_natCast_of_ne_zero
• toNat_coe_nat → toNat_natCast
• toNat_coe_nat_add_one → toNat_natCast_add_one
• coe_nat_dvd → natCast_dvd_natCast
• coe_nat_dvd_left → natCast_dvd
• coe_nat_dvd_right → dvd_natCast
• le_coe_nat_sub → le_natCast_sub
• succ_coe_nat_pos → succ_natCast_pos
• coe_nat_modEq_iff → natCast_modEq_iff
• coe_natAbs → natCast_natAbs
• coe_nat_eq_zero → natCast_eq_zero
• coe_nat_ne_zero → natCast_ne_zero
• coe_nat_ne_zero_iff_pos → natCast_ne_zero_iff_pos
• abs_coe_nat → abs_natCast
• coe_nat_nonpos_iff → natCast_nonpos_iff

Also rename Nat.coe_nat_dvd to Nat.cast_dvd_cast

@@ -513,15 +513,15 @@ abbrev groupPowers {x : M} {n : ℕ} (hpos : 0 < n) (hx : x ^ n = 1) : Group (po
     simp only [← pow_mul, Int.natMod, SubmonoidClass.coe_pow]
     rw [Int.negSucc_coe, ← Int.add_mul_emod_self (b := (m + 1 : ℕ))]
     nth_rw 1 [← mul_one ((m + 1 : ℕ) : ℤ)]
-    rw [← sub_eq_neg_add, ← mul_sub, ← Int.coe_pred_of_pos hpos]; norm_cast
-    simp only [Int.toNat_coe_nat]
+    rw [← sub_eq_neg_add, ← mul_sub, ← Int.natCast_pred_of_pos hpos]; norm_cast
+    simp only [Int.toNat_natCast]
     rw [mul_comm, pow_mul, ← pow_eq_pow_mod _ hx, mul_comm k, mul_assoc, pow_mul _ (_ % _),
       ← pow_eq_pow_mod _ hx, pow_mul, pow_mul]
   zpow_succ' m x := Subtype.ext <| by
     obtain ⟨_, k, rfl⟩ := x
     simp only [← pow_mul, Int.natMod, Int.ofNat_eq_coe, SubmonoidClass.coe_pow, coe_mul]
     norm_cast
-    iterate 2 rw [Int.toNat_coe_nat, mul_comm, pow_mul, ← pow_eq_pow_mod _ hx]
+    iterate 2 rw [Int.toNat_natCast, mul_comm, pow_mul, ← pow_eq_pow_mod _ hx]
     rw [← pow_mul _ m, mul_comm, pow_mul, ← pow_succ, ← pow_mul, mul_comm, pow_mul]
 
 /-- Exponentiation map from natural numbers to powers. -/

We change the following field in the definition of an additive commutative monoid:

 nsmul_succ : ∀ (n : ℕ) (x : G),
-  AddMonoid.nsmul (n + 1) x = x + AddMonoid.nsmul n x
+  AddMonoid.nsmul (n + 1) x = AddMonoid.nsmul n x + x

where the latter is more natural

We adjust the definitions of ^ in monoids, groups, etc. Originally there was a warning comment about why this natural order was preferred

use x * npowRec n x and not npowRec n x * x in the definition to make sure that definitional unfolding of npowRec is blocked, to avoid deep recursion issues.

but it seems to no longer apply.

Remarks on the PR :

• pow_succ and pow_succ' have switched their meanings.
• Most of the time, the proofs were adjusted by priming/unpriming one lemma, or exchanging left and right; a few proofs were more complicated to adjust.
• In particular, [Mathlib/NumberTheory/RamificationInertia.lean] used Ideal.IsPrime.mul_mem_pow which is defined in [Mathlib/RingTheory/DedekindDomain/Ideal.lean]. Changing the order of operation forced me to add the symmetric lemma Ideal.IsPrime.mem_pow_mul.
• the docstring for Cauchy condensation test in [Mathlib/Analysis/PSeries.lean] was mathematically incorrect, I added the mention that the function is antitone.

@@ -505,7 +505,7 @@ abbrev groupPowers {x : M} {n : ℕ} (hpos : 0 < n) (hx : x ^ n = 1) : Group (po
   mul_left_inv y := Subtype.ext <| by
     obtain ⟨_, k, rfl⟩ := y
     simp only [coe_one, coe_mul, SubmonoidClass.coe_pow]
-    rw [← pow_succ', Nat.sub_add_cancel hpos, ← pow_mul, mul_comm, pow_mul, hx, one_pow]
+    rw [← pow_succ, Nat.sub_add_cancel hpos, ← pow_mul, mul_comm, pow_mul, hx, one_pow]
   zpow z x := x ^ z.natMod n
   zpow_zero' z := by simp only [Int.natMod, Int.zero_emod, Int.toNat_zero, pow_zero]
   zpow_neg' m x := Subtype.ext <| by

The additive version are still incorrectly named, but these can easily be tracked down later (#11462) by searching for to_additive (attr := elab_as_elim).

@@ -275,26 +275,26 @@ then it holds for all elements of the supremum of `S`. -/
       If `C` holds for `0` and all elements of `S i` for all `i`, and is preserved under addition,
       then it holds for all elements of the supremum of `S`. "]
 theorem iSup_induction {ι : Sort*} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
-    (hp : ∀ (i), ∀ x ∈ S i, C x) (h1 : C 1) (hmul : ∀ x y, C x → C y → C (x * y)) : C x := by
+    (mem : ∀ (i), ∀ x ∈ S i, C x) (one : C 1) (mul : ∀ x y, C x → C y → C (x * y)) : C x := by
   rw [iSup_eq_closure] at hx
-  refine closure_induction hx (fun x hx => ?_) h1 hmul
+  refine closure_induction hx (fun x hx => ?_) one mul
   obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hx
-  exact hp _ _ hi
+  exact mem _ _ hi
 #align submonoid.supr_induction Submonoid.iSup_induction
 #align add_submonoid.supr_induction AddSubmonoid.iSup_induction
 
 /-- A dependent version of `Submonoid.iSup_induction`. -/
 @[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.iSup_induction`. "]
 theorem iSup_induction' {ι : Sort*} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
-    (hp : ∀ (i), ∀ (x) (hxS : x ∈ S i), C x (mem_iSup_of_mem i hxS)) (h1 : C 1 (one_mem _))
-    (hmul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (mul_mem ‹_› ‹_›)) {x : M}
+    (mem : ∀ (i), ∀ (x) (hxS : x ∈ S i), C x (mem_iSup_of_mem i hxS)) (one : C 1 (one_mem _))
+    (mul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (mul_mem ‹_› ‹_›)) {x : M}
     (hx : x ∈ ⨆ i, S i) : C x hx := by
   refine' Exists.elim (_ : ∃ Hx, C x Hx) fun (hx : x ∈ ⨆ i, S i) (hc : C x hx) => hc
   refine' @iSup_induction _ _ ι S (fun m => ∃ hm, C m hm) _ hx (fun i x hx => _) _ fun x y => _
-  · exact ⟨_, hp _ _ hx⟩
-  · exact ⟨_, h1⟩
+  · exact ⟨_, mem _ _ hx⟩
+  · exact ⟨_, one⟩
   · rintro ⟨_, Cx⟩ ⟨_, Cy⟩
-    exact ⟨_, hmul _ _ _ _ Cx Cy⟩
+    exact ⟨_, mul _ _ _ _ Cx Cy⟩
 #align submonoid.supr_induction' Submonoid.iSup_induction'
 #align add_submonoid.supr_induction' AddSubmonoid.iSup_induction'
 
@@ -430,11 +430,11 @@ theorem closure_induction_left {s : Set M} {p : (m : M) → m ∈ closure s →
 
 @[to_additive (attr := elab_as_elim)]
 theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
-    (H1 : p 1) (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x := by
+    (one : p 1) (mul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x := by
   have : x ∈ closure s := by simp [hs]
   induction this using closure_induction_left with
-  | one => exact H1
-  | mul_left x hx y _ ih => exact Hmul x hx y ih
+  | one => exact one
+  | mul_left x hx y _ ih => exact mul x hx y ih
 #align submonoid.induction_of_closure_eq_top_left Submonoid.induction_of_closure_eq_top_left
 #align add_submonoid.induction_of_closure_eq_top_left AddSubmonoid.induction_of_closure_eq_top_left
 

Classifies by adding issue number #10618 to porting notes claiming "simp can prove it".

@@ -58,7 +58,7 @@ theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 #align submonoid_class.coe_multiset_prod SubmonoidClass.coe_multiset_prod
 #align add_submonoid_class.coe_multiset_sum AddSubmonoidClass.coe_multiset_sum
 
-@[to_additive (attr := norm_cast)] -- Porting note: removed `simp`, `simp` can prove it
+@[to_additive (attr := norm_cast)] -- Porting note (#10618): removed `simp`, `simp` can prove it
 theorem coe_finset_prod {ι M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → S)
     (s : Finset ι) : ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
   map_prod (SubmonoidClass.subtype S) f s
@@ -107,13 +107,13 @@ namespace Submonoid
 
 variable (s : Submonoid M)
 
-@[to_additive (attr := norm_cast)] -- Porting note: removed `simp`, `simp` can prove it
+@[to_additive (attr := norm_cast)] -- Porting note (#10618): removed `simp`, `simp` can prove it
 theorem coe_list_prod (l : List s) : (l.prod : M) = (l.map (↑)).prod :=
   s.subtype.map_list_prod l
 #align submonoid.coe_list_prod Submonoid.coe_list_prod
 #align add_submonoid.coe_list_sum AddSubmonoid.coe_list_sum
 
-@[to_additive (attr := norm_cast)] -- Porting note: removed `simp`, `simp` can prove it
+@[to_additive (attr := norm_cast)] -- Porting note (#10618): removed `simp`, `simp` can prove it
 theorem coe_multiset_prod {M} [CommMonoid M] (S : Submonoid M) (m : Multiset S) :
     (m.prod : M) = (m.map (↑)).prod :=
   S.subtype.map_multiset_prod m

Classifies by adding issue number #11215 to porting notes claiming "TODO".

@@ -483,7 +483,7 @@ noncomputable instance decidableMemPowers : DecidablePred (· ∈ Submonoid.powe
   Classical.decPred _
 #align decidable_powers Submonoid.decidableMemPowers
 
--- Porting note: TODO the following instance should follow from a more general principle
+-- Porting note (#11215): TODO the following instance should follow from a more general principle
 -- See also mathlib4#2417
 noncomputable instance fintypePowers [Fintype M] : Fintype (powers a) :=
   inferInstanceAs <| Fintype {y // y ∈ powers a}

@@ -371,7 +371,7 @@ theorem card_le_one_iff_eq_bot : card S ≤ 1 ↔ S = ⊥ :=
 
 @[to_additive]
 lemma eq_bot_iff_card : S = ⊥ ↔ card S = 1 :=
-  ⟨by rintro rfl;  exact card_bot, eq_bot_of_card_eq⟩
+  ⟨by rintro rfl; exact card_bot, eq_bot_of_card_eq⟩
 
 end Submonoid
 

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

@@ -58,7 +58,7 @@ theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 #align submonoid_class.coe_multiset_prod SubmonoidClass.coe_multiset_prod
 #align add_submonoid_class.coe_multiset_sum AddSubmonoidClass.coe_multiset_sum
 
-@[to_additive (attr := norm_cast)] --Porting note: removed `simp`, `simp` can prove it
+@[to_additive (attr := norm_cast)] -- Porting note: removed `simp`, `simp` can prove it
 theorem coe_finset_prod {ι M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → S)
     (s : Finset ι) : ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
   map_prod (SubmonoidClass.subtype S) f s
@@ -107,13 +107,13 @@ namespace Submonoid
 
 variable (s : Submonoid M)
 
-@[to_additive (attr := norm_cast)] --Porting note: removed `simp`, `simp` can prove it
+@[to_additive (attr := norm_cast)] -- Porting note: removed `simp`, `simp` can prove it
 theorem coe_list_prod (l : List s) : (l.prod : M) = (l.map (↑)).prod :=
   s.subtype.map_list_prod l
 #align submonoid.coe_list_prod Submonoid.coe_list_prod
 #align add_submonoid.coe_list_sum AddSubmonoid.coe_list_sum
 
-@[to_additive (attr := norm_cast)] --Porting note: removed `simp`, `simp` can prove it
+@[to_additive (attr := norm_cast)] -- Porting note: removed `simp`, `simp` can prove it
 theorem coe_multiset_prod {M} [CommMonoid M] (S : Submonoid M) (m : Multiset S) :
     (m.prod : M) = (m.map (↑)).prod :=
   S.subtype.map_multiset_prod m

These did not respect the naming convention by having the coe as a prefix instead of a suffix, or vice-versa. Also add a bunch of norm_cast

@@ -408,7 +408,7 @@ theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
 theorem exists_multiset_of_mem_closure {M : Type*} [CommMonoid M] {s : Set M} {x : M}
     (hx : x ∈ closure s) : ∃ (l : Multiset M) (_ : ∀ y ∈ l, y ∈ s), l.prod = x := by
   obtain ⟨l, h1, h2⟩ := exists_list_of_mem_closure hx
-  exact ⟨l, h1, (Multiset.coe_prod l).trans h2⟩
+  exact ⟨l, h1, (Multiset.prod_coe l).trans h2⟩
 #align submonoid.exists_multiset_of_mem_closure Submonoid.exists_multiset_of_mem_closure
 #align add_submonoid.exists_multiset_of_mem_closure AddSubmonoid.exists_multiset_of_mem_closure
 

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

@@ -680,32 +680,32 @@ def multiples (x : A) : AddSubmonoid A :=
     Set.ext fun n => exists_congr fun i => by simp
 #align add_submonoid.multiples AddSubmonoid.multiples
 
-attribute [to_additive existing multiples] Submonoid.powers
+attribute [to_additive existing] Submonoid.powers
 
-attribute [to_additive (attr := simp) mem_multiples] Submonoid.mem_powers
+attribute [to_additive (attr := simp)] Submonoid.mem_powers
 #align add_submonoid.mem_multiples AddSubmonoid.mem_multiples
 
-attribute [to_additive (attr := norm_cast) coe_multiples] Submonoid.coe_powers
+attribute [to_additive (attr := norm_cast)] Submonoid.coe_powers
 #align add_submonoid.coe_multiples AddSubmonoid.coe_multiples
 
-attribute [to_additive mem_multiples_iff] Submonoid.mem_powers_iff
+attribute [to_additive] Submonoid.mem_powers_iff
 #align add_submonoid.mem_multiples_iff AddSubmonoid.mem_multiples_iff
 
-attribute [to_additive AddSubmonoid.decidableMemMultiples] Submonoid.decidableMemPowers
+attribute [to_additive] Submonoid.decidableMemPowers
 #align decidable_multiples AddSubmonoid.decidableMemMultiples
 
-attribute [to_additive AddSubmonoid.fintypeMultiples] Submonoid.fintypePowers
+attribute [to_additive] Submonoid.fintypePowers
 
-attribute [to_additive multiples_eq_closure] Submonoid.powers_eq_closure
+attribute [to_additive] Submonoid.powers_eq_closure
 #align add_submonoid.multiples_eq_closure AddSubmonoid.multiples_eq_closure
 
-attribute [to_additive multiples_le] Submonoid.powers_le
+attribute [to_additive] Submonoid.powers_le
 #align add_submonoid.multiples_subset AddSubmonoid.multiples_le
 
-attribute [to_additive (attr := simp) multiples_zero] Submonoid.powers_one
+attribute [to_additive (attr := simp)] Submonoid.powers_one
 #align add_submonoid.multiples_zero AddSubmonoid.multiples_zero
 
-attribute [to_additive addGroupMultiples "The additive submonoid generated by an element is
+attribute [to_additive "The additive submonoid generated by an element is
 an additive group if that element has finite order."] Submonoid.groupPowers
 
 end AddSubmonoid

I replaced a few "terminal" refine/refine's with exact.

The strategy was very simple-minded: essentially any refine whose following line had smaller indentation got replaced by exact and then I cleaned up the mess.

This PR certainly leaves some further terminal refines, but maybe the current change is beneficial.

@@ -294,7 +294,7 @@ theorem iSup_induction' {ι : Sort*} (S : ι → Submonoid M) {C : ∀ x, (x ∈
   · exact ⟨_, hp _ _ hx⟩
   · exact ⟨_, h1⟩
   · rintro ⟨_, Cx⟩ ⟨_, Cy⟩
-    refine' ⟨_, hmul _ _ _ _ Cx Cy⟩
+    exact ⟨_, hmul _ _ _ _ Cx Cy⟩
 #align submonoid.supr_induction' Submonoid.iSup_induction'
 #align add_submonoid.supr_induction' AddSubmonoid.iSup_induction'
 

• Introduce typeclass DecompositionMonoid, which says every element in the monoid is primal, i.e., whenever an element divides a product b * c, it can be factored into a product such that the factors divides b and c respectively. A domain is called pre-Schreier if its multiplicative monoid is a decomposition monoid, and these are more general than GCD domains.

• Show that any GCDMonoid is a DecompositionMonoid. In order for lemmas about DecompositionMonoids to automatically apply to UniqueFactorizationMonoids, we add instances from UniqueFactorizationMonoid α to Nonempty (NormalizedGCDMonoid α) to Nonempty (GCDMonoid α) to DecompositionMonoid α. (Zulip) See the bottom of message for an updated diagram of classes and instances.

• Introduce binary predicate IsRelPrime which says that the only common divisors of the two elements are units. Replace previous occurrences in mathlib by this predicate.

• Duplicate all lemmas about IsCoprime in Coprime/Basic (except three lemmas about smul) to IsRelPrime. Due to import constraints, they are spread into three files Algebra/Divisibility/Units (including key lemmas assuming DecompositionMonoid), GroupWithZero/Divisibility, and Coprime/Basic.

• Show IsCoprime always imply IsRelPrime and is equivalent to it in Bezout rings. To reduce duplication, the definition of Bezout rings and the GCDMonoid instance are moved from RingTheory/Bezout to RingTheory/PrincipalIdealDomain, and some results in PrincipalIdealDomain are generalized to Bezout rings.

• Remove the recently added file Squarefree/UniqueFactorizationMonoid and place the results appropriately within Squarefree/Basic. All results are generalized to DecompositionMonoid or weaker except the last one.

Zulip

With this PR, all the following instances (indicated by arrows) now work; this PR fills the central part.

                                                                          EuclideanDomain (bundled)
                                                                              ↙          ↖
                                                                 IsPrincipalIdealRing ← Field (bundled)
                                                                            ↓             ↓
         NormalizationMonoid ←          NormalizedGCDMonoid → GCDMonoid  IsBezout ← ValuationRing ← DiscreteValuationRing
                   ↓                             ↓                 ↘       ↙
Nonempty NormalizationMonoid ← Nonempty NormalizedGCDMonoid →  Nonempty GCDMonoid → IsIntegrallyClosed
                                                 ↑                    ↓
                    WfDvdMonoid ← UniqueFactorizationMonoid → DecompositionMonoid
                                                 ↑
                                       IsPrincipalIdealRing

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com> Co-authored-by: Oliver Nash <github@olivernash.org>

@@ -793,3 +793,9 @@ theorem ofAdd_image_multiples_eq_powers_ofAdd [AddMonoid A] {x : A} :
 #align of_add_image_multiples_eq_powers_of_add ofAdd_image_multiples_eq_powers_ofAdd
 
 end mul_add
+
+/-- The submonoid of primal elements in a cancellative commutative monoid with zero. -/
+def Submonoid.isPrimal (α) [CancelCommMonoidWithZero α] : Submonoid α where
+  carrier := {a | IsPrimal a}
+  mul_mem' := IsPrimal.mul
+  one_mem' := isUnit_one.isPrimal

Induction principles have to be fully dependent in order to work with the induction tactic. This is usually a good thing anyway, since the dependent version is often more convenient to use, and avoids the caller having to fumble with generalizing over an existential.

This changes the following induction principles (and their additive versions):

• Submonoid.closure_induction_{left,right}
• Subgroup.closure_induction_{left,right}
• Subgroup.closure_induction'' (no submonoid version exists)

Arguments to these lemmas have also been renamed to drop the H, as seems to be preferred for induction lemmas.

@@ -8,6 +8,7 @@ import Mathlib.Algebra.FreeMonoid.Basic
 import Mathlib.Data.Finset.NoncommProd
 import Mathlib.Data.Int.Order.Lemmas
 import Mathlib.GroupTheory.Submonoid.Operations
+import Mathlib.GroupTheory.Submonoid.MulOpposite
 
 #align_import group_theory.submonoid.membership from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
 
@@ -411,44 +412,52 @@ theorem exists_multiset_of_mem_closure {M : Type*} [CommMonoid M] {s : Set M} {x
 #align submonoid.exists_multiset_of_mem_closure Submonoid.exists_multiset_of_mem_closure
 #align add_submonoid.exists_multiset_of_mem_closure AddSubmonoid.exists_multiset_of_mem_closure
 
-@[to_additive]
-theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
-    (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x := by
-  rw [closure_eq_mrange] at h
+@[to_additive (attr := elab_as_elim)]
+theorem closure_induction_left {s : Set M} {p : (m : M) → m ∈ closure s → Prop}
+    (one : p 1 (one_mem _))
+    (mul_left : ∀ x (hx : x ∈ s), ∀ (y) hy, p y hy → p (x * y) (mul_mem (subset_closure hx) hy))
+    {x : M} (h : x ∈ closure s) :
+    p x h := by
+  simp_rw [closure_eq_mrange] at h
   obtain ⟨l, rfl⟩ := h
   induction' l using FreeMonoid.recOn with x y ih
-  · exact H1
-  · simpa only [map_mul, FreeMonoid.lift_eval_of] using Hmul _ x.prop _ ih
+  · exact one
+  · simp only [map_mul, FreeMonoid.lift_eval_of]
+    refine mul_left _ x.prop (FreeMonoid.lift Subtype.val y) _ (ih ?_)
+    simp only [closure_eq_mrange, mem_mrange, exists_apply_eq_apply]
 #align submonoid.closure_induction_left Submonoid.closure_induction_left
 #align add_submonoid.closure_induction_left AddSubmonoid.closure_induction_left
 
 @[to_additive (attr := elab_as_elim)]
 theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
-    (H1 : p 1) (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
-  closure_induction_left
-    (by
-      rw [hs]
-      exact mem_top _)
-    H1 Hmul
+    (H1 : p 1) (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x := by
+  have : x ∈ closure s := by simp [hs]
+  induction this using closure_induction_left with
+  | one => exact H1
+  | mul_left x hx y _ ih => exact Hmul x hx y ih
 #align submonoid.induction_of_closure_eq_top_left Submonoid.induction_of_closure_eq_top_left
 #align add_submonoid.induction_of_closure_eq_top_left AddSubmonoid.induction_of_closure_eq_top_left
 
-@[to_additive]
-theorem closure_induction_right {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
-    (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
-  @closure_induction_left _ _ (MulOpposite.unop ⁻¹' s) (p ∘ MulOpposite.unop) (MulOpposite.op x)
-    (closure_induction h (fun _x hx => subset_closure hx) (one_mem _)
-      fun _x _y hx hy => mul_mem hy hx)
-    H1 fun _x hx _y => Hmul _ _ hx
+@[to_additive (attr := elab_as_elim)]
+theorem closure_induction_right {s : Set M} {p : (m : M) → m ∈ closure s → Prop}
+    (one : p 1 (one_mem _))
+    (mul_right : ∀ x hx, ∀ (y) (hy : y ∈ s), p x hx → p (x * y) (mul_mem hx (subset_closure hy)))
+    {x : M} (h : x ∈ closure s) : p x h :=
+  closure_induction_left (s := MulOpposite.unop ⁻¹' s)
+    (p := fun m hm => p m.unop <| by rwa [← op_closure] at hm)
+    one
+    (fun _x hx _y hy => mul_right _ _ _ hx)
+    (by rwa [← op_closure])
 #align submonoid.closure_induction_right Submonoid.closure_induction_right
 #align add_submonoid.closure_induction_right AddSubmonoid.closure_induction_right
 
 @[to_additive (attr := elab_as_elim)]
 theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
-    (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
-  closure_induction_right
-    (by rw [hs]; exact mem_top _)
-    H1 Hmul
+    (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x := by
+  have : x ∈ closure s := by simp [hs]
+  induction this using closure_induction_right with
+  | one => exact H1
+  | mul_right x _ y hy ih => exact Hmul x y hy ih
 #align submonoid.induction_of_closure_eq_top_right Submonoid.induction_of_closure_eq_top_right
 #align add_submonoid.induction_of_closure_eq_top_right AddSubmonoid.induction_of_closure_eq_top_right
 

The FunLike hierarchy is very big and gets scanned through each time we need a coercion (via the CoeFun instance). It looks like unbundled inheritance suits Lean 4 better here. The only class that still extends FunLike is EquivLike, since that has a custom coe_injective' field that is easier to implement. All other classes should take FunLike or EquivLike as a parameter.

Zulip thread

Important changes

Previously, morphism classes would be Type-valued and extend FunLike:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  extends FunLike F A B :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

After this PR, they should be Prop-valued and take FunLike as a parameter:

/-- `MyHomClass F A B` states that `F` is a type of `MyClass.op`-preserving morphisms.
You should extend this class when you extend `MyHom`. -/
class MyHomClass (F : Type*) (A B : outParam <| Type*) [MyClass A] [MyClass B]
  [FunLike F A B] : Prop :=
(map_op : ∀ (f : F) (x y : A), f (MyClass.op x y) = MyClass.op (f x) (f y))

(Note that A B stay marked as outParam even though they are not purely required to be so due to the FunLike parameter already filling them in. This is required to see through type synonyms, which is important in the category theory library. Also, I think keeping them as outParam is slightly faster.)

Similarly, MyEquivClass should take EquivLike as a parameter.

As a result, every mention of [MyHomClass F A B] should become [FunLike F A B] [MyHomClass F A B].

Remaining issues

Slower (failing) search

While overall this gives some great speedups, there are some cases that are noticeably slower. In particular, a failing application of a lemma such as map_mul is more expensive. This is due to suboptimal processing of arguments. For example:

variable [FunLike F M N] [Mul M] [Mul N] (f : F) (x : M) (y : M)

theorem map_mul [MulHomClass F M N] : f (x * y) = f x * f y

example [AddHomClass F A B] : f (x * y) = f x * f y := map_mul f _ _

Before this PR, applying map_mul f gives the goals [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Since M and N are out_params, [MulHomClass F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found.

After this PR, the goals become [FunLike F ?M ?N] [Mul ?M] [Mul ?N] [MulHomClass F ?M ?N]. Now [FunLike F ?M ?N] is synthesized first, supplies values for ?M and ?N and then the Mul M and Mul N instances can be found, before trying MulHomClass F M N which fails. Since the Mul hierarchy is very big, this can be slow to fail, especially when there is no such Mul instance.

A long-term but harder to achieve solution would be to specify the order in which instance goals get solved. For example, we'd like to change the arguments to map_mul to look like [FunLike F M N] [Mul M] [Mul N] [highPriority <| MulHomClass F M N] because MulHomClass fails or succeeds much faster than the others.

As a consequence, the simpNF linter is much slower since by design it tries and fails to apply many map_ lemmas. The same issue occurs a few times in existing calls to simp [map_mul], where map_mul is tried "too soon" and fails. Thanks to the speedup of leanprover/lean4#2478 the impact is very limited, only in files that already were close to the timeout.

simp not firing sometimes

This affects map_smulₛₗ and related definitions. For simp lemmas Lean apparently uses a slightly different mechanism to find instances, so that rw can find every argument to map_smulₛₗ successfully but simp can't: leanprover/lean4#3701.

Missing instances due to unification failing

Especially in the category theory library, we might sometimes have a type A which is also accessible as a synonym (Bundled A hA).1. Instance synthesis doesn't always work if we have f : A →* B but x * y : (Bundled A hA).1 or vice versa. This seems to be mostly fixed by keeping A B as outParams in MulHomClass F A B. (Presumably because Lean will do a definitional check A =?= (Bundled A hA).1 instead of using the syntax in the discrimination tree.)

Workaround for issues

The timeouts can be worked around for now by specifying which map_mul we mean, either as map_mul f for some explicit f, or as e.g. MonoidHomClass.map_mul.

map_smulₛₗ not firing as simp lemma can be worked around by going back to the pre-FunLike situation and making LinearMap.map_smulₛₗ a simp lemma instead of the generic map_smulₛₗ. Writing simp [map_smulₛₗ _] also works.

Co-authored-by: Matthew Ballard <matt@mrb.email> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Scott Morrison <scott@tqft.net> Co-authored-by: Anne Baanen <Vierkantor@users.noreply.github.com>

@@ -571,7 +571,8 @@ theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x
 #align submonoid.log_pow_int_eq_self Submonoid.log_pow_int_eq_self
 
 @[simp]
-theorem map_powers {N : Type*} {F : Type*} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :
+theorem map_powers {N : Type*} {F : Type*} [Monoid N] [FunLike F M N] [MonoidHomClass F M N]
+    (f : F) (m : M) :
     (powers m).map f = powers (f m) := by
   simp only [powers_eq_closure, map_mclosure f, Set.image_singleton]
 #align submonoid.map_powers Submonoid.map_powers

This allows more files to not depend on Algebra.GroupPower.Lemmas, which will soon stop existing.

Part of #9411

@@ -6,6 +6,7 @@ Amelia Livingston, Yury Kudryashov
 -/
 import Mathlib.Algebra.FreeMonoid.Basic
 import Mathlib.Data.Finset.NoncommProd
+import Mathlib.Data.Int.Order.Lemmas
 import Mathlib.GroupTheory.Submonoid.Operations
 
 #align_import group_theory.submonoid.membership from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"

Started from Algebra/Periodic.lean with some snowball sampling. Seems to be somewhat disjoint from the tree shaking in #9347.

@@ -4,10 +4,9 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzzard,
 Amelia Livingston, Yury Kudryashov
 -/
-import Mathlib.GroupTheory.Submonoid.Operations
-import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Algebra.FreeMonoid.Basic
 import Mathlib.Data.Finset.NoncommProd
+import Mathlib.GroupTheory.Submonoid.Operations
 
 #align_import group_theory.submonoid.membership from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
 

This is a follow-up to #9215. It changes the following theorems and definitions:

• IsOpen.exists_subset_affineIndependent_span_eq_top
• IsConformalMap
• SimpleGraph.induce_connected_of_patches
• Submonoid.exists_list_of_mem_closure
• AddSubmonoid.exists_list_of_mem_closure
• AffineSubspace.mem_affineSpan_insert_iff
• AffineBasis.exists_affine_subbasis
• exists_affineIndependent
• LinearMap.mem_submoduleImage
• Basis.basis_singleton_iff
• atom_iff_nonzero_span
• finrank_eq_one_iff'
• Submodule.basis_of_pid_aux
• exists_linearIndependent_extension
• exists_linearIndependent
• countable_cover_nhdsWithin_of_sigma_compact
• mem_residual

Also deprecate ENNReal.exists_ne_top'.

@@ -398,8 +398,8 @@ theorem closure_eq_image_prod (s : Set M) :
 
 @[to_additive]
 theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
-    ∃ (l : List M) (_ : ∀ y ∈ l, y ∈ s), l.prod = x := by
-  rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image_iff_bex] at hx
+    ∃ l : List M, (∀ y ∈ l, y ∈ s) ∧ l.prod = x := by
+  rwa [← SetLike.mem_coe, closure_eq_image_prod, Set.mem_image] at hx
 #align submonoid.exists_list_of_mem_closure Submonoid.exists_list_of_mem_closure
 #align add_submonoid.exists_list_of_mem_closure AddSubmonoid.exists_list_of_mem_closure
 

See Zulip thread for the discussion.

@@ -477,7 +477,7 @@ noncomputable instance decidableMemPowers : DecidablePred (· ∈ Submonoid.powe
 -- Porting note: TODO the following instance should follow from a more general principle
 -- See also mathlib4#2417
 noncomputable instance fintypePowers [Fintype M] : Fintype (powers a) :=
-  inferInstanceAs $ Fintype {y // y ∈ powers a}
+  inferInstanceAs <| Fintype {y // y ∈ powers a}
 
 theorem powers_eq_closure (n : M) : powers n = closure {n} := by
   ext
@@ -487,7 +487,7 @@ theorem powers_eq_closure (n : M) : powers n = closure {n} := by
 lemma powers_le {n : M} {P : Submonoid M} : powers n ≤ P ↔ n ∈ P := by simp [powers_eq_closure]
 #align submonoid.powers_subset Submonoid.powers_le
 
-lemma powers_one : powers (1 : M) = ⊥ := bot_unique <| powers_le.2 $ one_mem _
+lemma powers_one : powers (1 : M) = ⊥ := bot_unique <| powers_le.2 <| one_mem _
 #align submonoid.powers_one Submonoid.powers_one
 
 /-- The submonoid generated by an element is a group if that element has finite order. -/

Changes in this PR shouldn't change the public API. The only changes about ∃ x ∈ s, _ is inside a proof.

Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com>

@@ -580,7 +580,7 @@ theorem map_powers {N : Type*} {F : Type*} [Monoid N] [MonoidHomClass F M N] (f
 @[to_additive
       "If all the elements of a set `s` commute, then `closure s` forms an additive
       commutative monoid."]
-def closureCommMonoidOfComm {s : Set M} (hcomm : ∀ (a) (_ : a ∈ s) (b) (_ : b ∈ s), a * b = b * a) :
+def closureCommMonoidOfComm {s : Set M} (hcomm : ∀ a ∈ s, ∀ b ∈ s, a * b = b * a) :
     CommMonoid (closure s) :=
   { (closure s).toMonoid with
     mul_comm := fun x y => by

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

@@ -454,7 +454,7 @@ theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : clo
 
 /-- The submonoid generated by an element. -/
 def powers (n : M) : Submonoid M :=
-  Submonoid.copy (mrange (powersHom M n)) (Set.range ((· ^ ·) n : ℕ → M)) <|
+  Submonoid.copy (mrange (powersHom M n)) (Set.range (n ^ · : ℕ → M)) <|
     Set.ext fun n => exists_congr fun i => by simp; rfl
 #align submonoid.powers Submonoid.powers
 

@@ -60,7 +60,7 @@ theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 @[to_additive (attr := norm_cast)] --Porting note: removed `simp`, `simp` can prove it
 theorem coe_finset_prod {ι M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → S)
     (s : Finset ι) : ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
-  (SubmonoidClass.subtype S : _ →* M).map_prod f s
+  map_prod (SubmonoidClass.subtype S) f s
 #align submonoid_class.coe_finset_prod SubmonoidClass.coe_finset_prod
 #align add_submonoid_class.coe_finset_sum AddSubmonoidClass.coe_finset_sum
 
@@ -122,7 +122,7 @@ theorem coe_multiset_prod {M} [CommMonoid M] (S : Submonoid M) (m : Multiset S)
 @[to_additive (attr := norm_cast, simp)]
 theorem coe_finset_prod {ι M} [CommMonoid M] (S : Submonoid M) (f : ι → S) (s : Finset ι) :
     ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
-  S.subtype.map_prod f s
+  map_prod S.subtype f s
 #align submonoid.coe_finset_prod Submonoid.coe_finset_prod
 #align add_submonoid.coe_finset_sum AddSubmonoid.coe_finset_sum
 

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -232,14 +232,14 @@ theorem coe_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
 
 @[to_additive]
 theorem mem_sup_left {S T : Submonoid M} : ∀ {x : M}, x ∈ S → x ∈ S ⊔ T := by
-  rw [←SetLike.le_def]
+  rw [← SetLike.le_def]
   exact le_sup_left
 #align submonoid.mem_sup_left Submonoid.mem_sup_left
 #align add_submonoid.mem_sup_left AddSubmonoid.mem_sup_left
 
 @[to_additive]
 theorem mem_sup_right {S T : Submonoid M} : ∀ {x : M}, x ∈ T → x ∈ S ⊔ T := by
-  rw [←SetLike.le_def]
+  rw [← SetLike.le_def]
   exact le_sup_right
 #align submonoid.mem_sup_right Submonoid.mem_sup_right
 #align add_submonoid.mem_sup_right AddSubmonoid.mem_sup_right
@@ -253,7 +253,7 @@ theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T)
 @[to_additive]
 theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Submonoid M} (i : ι) :
     ∀ {x : M}, x ∈ S i → x ∈ iSup S := by
-  rw [←SetLike.le_def]
+  rw [← SetLike.le_def]
   exact le_iSup _ _
 #align submonoid.mem_supr_of_mem Submonoid.mem_iSup_of_mem
 #align add_submonoid.mem_supr_of_mem AddSubmonoid.mem_iSup_of_mem
@@ -261,7 +261,7 @@ theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Submonoid M} (i : ι) :
 @[to_additive]
 theorem mem_sSup_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
     ∀ {x : M}, x ∈ s → x ∈ sSup S := by
-  rw [←SetLike.le_def]
+  rw [← SetLike.le_def]
   exact le_sSup hs
 #align submonoid.mem_Sup_of_mem Submonoid.mem_sSup_of_mem
 #align add_submonoid.mem_Sup_of_mem AddSubmonoid.mem_sSup_of_mem

The cardinality of a subgroup is greater than the order of any of its elements.

Rename

• order_eq_card_zpowers → Fintype.card_zpowers
• order_eq_card_zpowers' → Nat.card_zpowers (and turn it around to match Nat.card_subgroupPowers)
• Submonoid.powers_subset → Submonoid.powers_le
• orderOf_dvd_card_univ → orderOf_dvd_card
• orderOf_subgroup → Subgroup.orderOf
• Subgroup.nonempty → Subgroup.coe_nonempty

@@ -484,13 +484,10 @@ theorem powers_eq_closure (n : M) : powers n = closure {n} := by
   exact mem_closure_singleton.symm
 #align submonoid.powers_eq_closure Submonoid.powers_eq_closure
 
-theorem powers_subset {n : M} {P : Submonoid M} (h : n ∈ P) : powers n ≤ P := fun x hx =>
-  match x, hx with
-  | _, ⟨i, rfl⟩ => pow_mem h i
-#align submonoid.powers_subset Submonoid.powers_subset
+lemma powers_le {n : M} {P : Submonoid M} : powers n ≤ P ↔ n ∈ P := by simp [powers_eq_closure]
+#align submonoid.powers_subset Submonoid.powers_le
 
-theorem powers_one : powers (1 : M) = ⊥ :=
-  bot_unique <| powers_subset (one_mem _)
+lemma powers_one : powers (1 : M) = ⊥ := bot_unique <| powers_le.2 $ one_mem _
 #align submonoid.powers_one Submonoid.powers_one
 
 /-- The submonoid generated by an element is a group if that element has finite order. -/
@@ -692,8 +689,8 @@ attribute [to_additive AddSubmonoid.fintypeMultiples] Submonoid.fintypePowers
 attribute [to_additive multiples_eq_closure] Submonoid.powers_eq_closure
 #align add_submonoid.multiples_eq_closure AddSubmonoid.multiples_eq_closure
 
-attribute [to_additive multiples_subset] Submonoid.powers_subset
-#align add_submonoid.multiples_subset AddSubmonoid.multiples_subset
+attribute [to_additive multiples_le] Submonoid.powers_le
+#align add_submonoid.multiples_subset AddSubmonoid.multiples_le
 
 attribute [to_additive (attr := simp) multiples_zero] Submonoid.powers_one
 #align add_submonoid.multiples_zero AddSubmonoid.multiples_zero

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

Renames

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

New lemmas

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

Other changes

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

@@ -318,8 +318,7 @@ theorem closure_range_of : closure (Set.range <| @of α) = ⊤ :=
 end FreeMonoid
 
 namespace Submonoid
-
-variable [Monoid M]
+variable [Monoid M] {a : M}
 
 open MonoidHom
 
@@ -471,6 +470,15 @@ theorem mem_powers_iff (x z : M) : x ∈ powers z ↔ ∃ n : ℕ, z ^ n = x :=
   Iff.rfl
 #align submonoid.mem_powers_iff Submonoid.mem_powers_iff
 
+noncomputable instance decidableMemPowers : DecidablePred (· ∈ Submonoid.powers a) :=
+  Classical.decPred _
+#align decidable_powers Submonoid.decidableMemPowers
+
+-- Porting note: TODO the following instance should follow from a more general principle
+-- See also mathlib4#2417
+noncomputable instance fintypePowers [Fintype M] : Fintype (powers a) :=
+  inferInstanceAs $ Fintype {y // y ∈ powers a}
+
 theorem powers_eq_closure (n : M) : powers n = closure {n} := by
   ext
   exact mem_closure_singleton.symm
@@ -676,6 +684,11 @@ attribute [to_additive (attr := norm_cast) coe_multiples] Submonoid.coe_powers
 attribute [to_additive mem_multiples_iff] Submonoid.mem_powers_iff
 #align add_submonoid.mem_multiples_iff AddSubmonoid.mem_multiples_iff
 
+attribute [to_additive AddSubmonoid.decidableMemMultiples] Submonoid.decidableMemPowers
+#align decidable_multiples AddSubmonoid.decidableMemMultiples
+
+attribute [to_additive AddSubmonoid.fintypeMultiples] Submonoid.fintypePowers
+
 attribute [to_additive multiples_eq_closure] Submonoid.powers_eq_closure
 #align add_submonoid.multiples_eq_closure AddSubmonoid.multiples_eq_closure
 

@@ -197,11 +197,11 @@ namespace Submonoid
 @[to_additive]
 theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S)
     {x : M} : (x ∈ ⨆ i, S i) ↔ ∃ i, x ∈ S i := by
-  refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_iSup S i) hi⟩
+  refine ⟨?_, fun ⟨i, hi⟩ ↦ le_iSup S i hi⟩
   suffices x ∈ closure (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
     simpa only [closure_iUnion, closure_eq (S _)] using this
-  refine' fun hx => closure_induction hx (fun _ => mem_iUnion.1) _ _
-  · exact hι.elim fun i => ⟨i, (S i).one_mem⟩
+  refine fun hx ↦ closure_induction hx (fun _ ↦ mem_iUnion.1) ?_ ?_
+  · exact hι.elim fun i ↦ ⟨i, (S i).one_mem⟩
   · rintro x y ⟨i, hi⟩ ⟨j, hj⟩
     rcases hS i j with ⟨k, hki, hkj⟩
     exact ⟨k, (S k).mul_mem (hki hi) (hkj hj)⟩
@@ -210,8 +210,8 @@ theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (
 
 @[to_additive]
 theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S) :
-    ((⨆ i, S i : Submonoid M) : Set M) = ⋃ i, ↑(S i) :=
-  Set.ext fun x => by simp [mem_iSup_of_directed hS]
+    ((⨆ i, S i : Submonoid M) : Set M) = ⋃ i, S i :=
+  Set.ext fun x ↦ by simp [mem_iSup_of_directed hS]
 #align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directed
 #align add_submonoid.coe_supr_of_directed AddSubmonoid.coe_iSup_of_directed
 

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

@@ -342,6 +342,39 @@ theorem closure_singleton_one : closure ({1} : Set M) = ⊥ := by
   simp [eq_bot_iff_forall, mem_closure_singleton]
 #align submonoid.closure_singleton_one Submonoid.closure_singleton_one
 
+section Submonoid
+variable {S : Submonoid M} [Fintype S]
+open Fintype
+
+/- curly brackets `{}` are used here instead of instance brackets `[]` because
+  the instance in a goal is often not the same as the one inferred by type class inference.  -/
+@[to_additive]
+theorem card_bot {_ : Fintype (⊥ : Submonoid M)} : card (⊥ : Submonoid M) = 1 :=
+  card_eq_one_iff.2
+    ⟨⟨(1 : M), Set.mem_singleton 1⟩, fun ⟨_y, hy⟩ => Subtype.eq <| mem_bot.1 hy⟩
+
+@[to_additive]
+theorem eq_bot_of_card_le (h : card S ≤ 1) : S = ⊥ :=
+  let _ := card_le_one_iff_subsingleton.mp h
+  eq_bot_of_subsingleton S
+
+@[to_additive]
+theorem eq_bot_of_card_eq (h : card S = 1) : S = ⊥ :=
+  S.eq_bot_of_card_le (le_of_eq h)
+
+@[to_additive card_le_one_iff_eq_bot]
+theorem card_le_one_iff_eq_bot : card S ≤ 1 ↔ S = ⊥ :=
+  ⟨fun h =>
+    (eq_bot_iff_forall _).2 fun x hx => by
+      simpa [Subtype.ext_iff] using card_le_one_iff.1 h ⟨x, hx⟩ 1,
+    fun h => by simp [h]⟩
+
+@[to_additive]
+lemma eq_bot_iff_card : S = ⊥ ↔ card S = 1 :=
+  ⟨by rintro rfl;  exact card_bot, eq_bot_of_card_eq⟩
+
+end Submonoid
+
 @[to_additive]
 theorem _root_.FreeMonoid.mrange_lift {α} (f : α → M) :
     mrange (FreeMonoid.lift f) = closure (Set.range f) := by

This was split from #6629 after @tb65536's golf, the construction here now no longer needed there.

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

@@ -452,6 +452,31 @@ theorem powers_one : powers (1 : M) = ⊥ :=
   bot_unique <| powers_subset (one_mem _)
 #align submonoid.powers_one Submonoid.powers_one
 
+/-- The submonoid generated by an element is a group if that element has finite order. -/
+abbrev groupPowers {x : M} {n : ℕ} (hpos : 0 < n) (hx : x ^ n = 1) : Group (powers x) where
+  inv x := x ^ (n - 1)
+  mul_left_inv y := Subtype.ext <| by
+    obtain ⟨_, k, rfl⟩ := y
+    simp only [coe_one, coe_mul, SubmonoidClass.coe_pow]
+    rw [← pow_succ', Nat.sub_add_cancel hpos, ← pow_mul, mul_comm, pow_mul, hx, one_pow]
+  zpow z x := x ^ z.natMod n
+  zpow_zero' z := by simp only [Int.natMod, Int.zero_emod, Int.toNat_zero, pow_zero]
+  zpow_neg' m x := Subtype.ext <| by
+    obtain ⟨_, k, rfl⟩ := x
+    simp only [← pow_mul, Int.natMod, SubmonoidClass.coe_pow]
+    rw [Int.negSucc_coe, ← Int.add_mul_emod_self (b := (m + 1 : ℕ))]
+    nth_rw 1 [← mul_one ((m + 1 : ℕ) : ℤ)]
+    rw [← sub_eq_neg_add, ← mul_sub, ← Int.coe_pred_of_pos hpos]; norm_cast
+    simp only [Int.toNat_coe_nat]
+    rw [mul_comm, pow_mul, ← pow_eq_pow_mod _ hx, mul_comm k, mul_assoc, pow_mul _ (_ % _),
+      ← pow_eq_pow_mod _ hx, pow_mul, pow_mul]
+  zpow_succ' m x := Subtype.ext <| by
+    obtain ⟨_, k, rfl⟩ := x
+    simp only [← pow_mul, Int.natMod, Int.ofNat_eq_coe, SubmonoidClass.coe_pow, coe_mul]
+    norm_cast
+    iterate 2 rw [Int.toNat_coe_nat, mul_comm, pow_mul, ← pow_eq_pow_mod _ hx]
+    rw [← pow_mul _ m, mul_comm, pow_mul, ← pow_succ, ← pow_mul, mul_comm, pow_mul]
+
 /-- Exponentiation map from natural numbers to powers. -/
 @[simps!]
 def pow (n : M) (m : ℕ) : powers n :=
@@ -627,6 +652,9 @@ attribute [to_additive multiples_subset] Submonoid.powers_subset
 attribute [to_additive (attr := simp) multiples_zero] Submonoid.powers_one
 #align add_submonoid.multiples_zero AddSubmonoid.multiples_zero
 
+attribute [to_additive addGroupMultiples "The additive submonoid generated by an element is
+an additive group if that element has finite order."] Submonoid.groupPowers
+
 end AddSubmonoid
 
 /-! Lemmas about additive closures of `Subsemigroup`. -/

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

This has nice performance benefits.

@@ -36,7 +36,7 @@ submonoid, submonoids
 
 open BigOperators
 
-variable {M A B : Type _}
+variable {M A B : Type*}
 
 section Assoc
 
@@ -94,7 +94,7 @@ theorem multiset_prod_mem {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M]
 @[to_additive
       "Sum of elements in an `AddSubmonoid` of an `AddCommMonoid` indexed by a `Finset`
       is in the `AddSubmonoid`."]
-theorem prod_mem {M : Type _} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] {ι : Type _}
+theorem prod_mem {M : Type*} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] {ι : Type*}
     {t : Finset ι} {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : (∏ c in t, f c) ∈ S :=
   multiset_prod_mem (t.1.map f) fun _x hx =>
     let ⟨i, hi, hix⟩ := Multiset.mem_map.1 hx
@@ -161,7 +161,7 @@ theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h :
 @[to_additive
       "Sum of elements in an `AddSubmonoid` of an `AddCommMonoid` indexed by a `Finset`
       is in the `AddSubmonoid`."]
-theorem prod_mem {M : Type _} [CommMonoid M] (S : Submonoid M) {ι : Type _} {t : Finset ι}
+theorem prod_mem {M : Type*} [CommMonoid M] (S : Submonoid M) {ι : Type*} {t : Finset ι}
     {f : ι → M} (h : ∀ c ∈ t, f c ∈ S) : (∏ c in t, f c) ∈ S :=
   S.multiset_prod_mem (t.1.map f) fun _ hx =>
     let ⟨i, hi, hix⟩ := Multiset.mem_map.1 hx
@@ -170,7 +170,7 @@ theorem prod_mem {M : Type _} [CommMonoid M] (S : Submonoid M) {ι : Type _} {t
 #align add_submonoid.sum_mem AddSubmonoid.sum_mem
 
 @[to_additive]
-theorem noncommProd_mem (S : Submonoid M) {ι : Type _} (t : Finset ι) (f : ι → M) (comm)
+theorem noncommProd_mem (S : Submonoid M) {ι : Type*} (t : Finset ι) (f : ι → M) (comm)
     (h : ∀ c ∈ t, f c ∈ S) : t.noncommProd f comm ∈ S := by
   apply multiset_noncommProd_mem
   intro y
@@ -251,7 +251,7 @@ theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T)
 #align add_submonoid.add_mem_sup AddSubmonoid.add_mem_sup
 
 @[to_additive]
-theorem mem_iSup_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
+theorem mem_iSup_of_mem {ι : Sort*} {S : ι → Submonoid M} (i : ι) :
     ∀ {x : M}, x ∈ S i → x ∈ iSup S := by
   rw [←SetLike.le_def]
   exact le_iSup _ _
@@ -273,7 +273,7 @@ then it holds for all elements of the supremum of `S`. -/
       " An induction principle for elements of `⨆ i, S i`.
       If `C` holds for `0` and all elements of `S i` for all `i`, and is preserved under addition,
       then it holds for all elements of the supremum of `S`. "]
-theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
+theorem iSup_induction {ι : Sort*} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
     (hp : ∀ (i), ∀ x ∈ S i, C x) (h1 : C 1) (hmul : ∀ x y, C x → C y → C (x * y)) : C x := by
   rw [iSup_eq_closure] at hx
   refine closure_induction hx (fun x hx => ?_) h1 hmul
@@ -284,7 +284,7 @@ theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {
 
 /-- A dependent version of `Submonoid.iSup_induction`. -/
 @[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.iSup_induction`. "]
-theorem iSup_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
+theorem iSup_induction' {ι : Sort*} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
     (hp : ∀ (i), ∀ (x) (hxS : x ∈ S i), C x (mem_iSup_of_mem i hxS)) (h1 : C 1 (one_mem _))
     (hmul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (mul_mem ‹_› ‹_›)) {x : M}
     (hx : x ∈ ⨆ i, S i) : C x hx := by
@@ -303,7 +303,7 @@ end NonAssoc
 
 namespace FreeMonoid
 
-variable {α : Type _}
+variable {α : Type*}
 
 open Submonoid
 
@@ -372,7 +372,7 @@ theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
 #align add_submonoid.exists_list_of_mem_closure AddSubmonoid.exists_list_of_mem_closure
 
 @[to_additive]
-theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {x : M}
+theorem exists_multiset_of_mem_closure {M : Type*} [CommMonoid M] {s : Set M} {x : M}
     (hx : x ∈ closure s) : ∃ (l : Multiset M) (_ : ∀ y ∈ l, y ∈ s), l.prod = x := by
   obtain ⟨l, h1, h2⟩ := exists_list_of_mem_closure hx
   exact ⟨l, h1, (Multiset.coe_prod l).trans h2⟩
@@ -508,7 +508,7 @@ theorem log_pow_int_eq_self {x : ℤ} (h : 1 < x.natAbs) (m : ℕ) : log (pow x
 #align submonoid.log_pow_int_eq_self Submonoid.log_pow_int_eq_self
 
 @[simp]
-theorem map_powers {N : Type _} {F : Type _} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :
+theorem map_powers {N : Type*} {F : Type*} [Monoid N] [MonoidHomClass F M N] (f : F) (m : M) :
     (powers m).map f = powers (f m) := by
   simp only [powers_eq_closure, map_mclosure f, Set.image_singleton]
 #align submonoid.map_powers Submonoid.map_powers
@@ -559,7 +559,7 @@ theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulActio
 
 namespace Submonoid
 
-variable {N : Type _} [CommMonoid N]
+variable {N : Type*} [CommMonoid N]
 
 open MonoidHom
 
@@ -634,7 +634,7 @@ end AddSubmonoid
 
 namespace MulMemClass
 
-variable {R : Type _} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M}
+variable {R : Type*} [NonUnitalNonAssocSemiring R] [SetLike M R] [MulMemClass M R] {S : M}
   {a b : R}
 
 /-- The product of an element of the additive closure of a multiplicative subsemigroup `M`
@@ -680,7 +680,7 @@ elements. -/
 @[to_additive
       "An element is in the closure of a two-element set if it is a linear combination of
       those two elements."]
-theorem mem_closure_pair {A : Type _} [CommMonoid A] (a b c : A) :
+theorem mem_closure_pair {A : Type*} [CommMonoid A] (a b c : A) :
     c ∈ Submonoid.closure ({a, b} : Set A) ↔ ∃ m n : ℕ, a ^ m * b ^ n = c := by
   rw [← Set.singleton_union, Submonoid.closure_union, mem_sup]
   simp_rw [mem_closure_singleton, exists_exists_eq_and]

@@ -46,21 +46,21 @@ namespace SubmonoidClass
 
 @[to_additive (attr := norm_cast, simp)]
 theorem coe_list_prod (l : List S) : (l.prod : M) = (l.map (↑)).prod :=
-  (SubmonoidClass.Subtype S : _ →* M).map_list_prod l
+  (SubmonoidClass.subtype S : _ →* M).map_list_prod l
 #align submonoid_class.coe_list_prod SubmonoidClass.coe_list_prod
 #align add_submonoid_class.coe_list_sum AddSubmonoidClass.coe_list_sum
 
 @[to_additive (attr := norm_cast, simp)]
 theorem coe_multiset_prod {M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (m : Multiset S) :
     (m.prod : M) = (m.map (↑)).prod :=
-  (SubmonoidClass.Subtype S : _ →* M).map_multiset_prod m
+  (SubmonoidClass.subtype S : _ →* M).map_multiset_prod m
 #align submonoid_class.coe_multiset_prod SubmonoidClass.coe_multiset_prod
 #align add_submonoid_class.coe_multiset_sum AddSubmonoidClass.coe_multiset_sum
 
 @[to_additive (attr := norm_cast)] --Porting note: removed `simp`, `simp` can prove it
 theorem coe_finset_prod {ι M} [CommMonoid M] [SetLike B M] [SubmonoidClass B M] (f : ι → S)
     (s : Finset ι) : ↑(∏ i in s, f i) = (∏ i in s, f i : M) :=
-  (SubmonoidClass.Subtype S : _ →* M).map_prod f s
+  (SubmonoidClass.subtype S : _ →* M).map_prod f s
 #align submonoid_class.coe_finset_prod SubmonoidClass.coe_finset_prod
 #align add_submonoid_class.coe_finset_sum AddSubmonoidClass.coe_finset_sum
 

• depends on: #5966

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

@@ -3,17 +3,14 @@ Copyright (c) 2018 Johannes Hölzl. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzzard,
 Amelia Livingston, Yury Kudryashov
-
-! This file was ported from Lean 3 source module group_theory.submonoid.membership
-! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.GroupTheory.Submonoid.Operations
 import Mathlib.Algebra.BigOperators.Basic
 import Mathlib.Algebra.FreeMonoid.Basic
 import Mathlib.Data.Finset.NoncommProd
 
+#align_import group_theory.submonoid.membership from "leanprover-community/mathlib"@"e655e4ea5c6d02854696f97494997ba4c31be802"
+
 /-!
 # Submonoids: membership criteria
 

Grepping for [^ .:{-] [^ :] and reviewing the results. Once I started I couldn't stop. :-)

Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

@@ -659,7 +659,7 @@ theorem mul_mem_add_closure (ha : a ∈ AddSubmonoid.closure (S : Set R))
     (hb : b ∈ AddSubmonoid.closure (S : Set R)) : a * b ∈ AddSubmonoid.closure (S : Set R) := by
   revert a
   refine' @AddSubmonoid.closure_induction _ _ _
-    (fun z =>  ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S)
+    (fun z => ∀ {a : R}, a ∈ AddSubmonoid.closure ↑S → a * z ∈ AddSubmonoid.closure ↑S)
       _ hb _ _ _ <;> clear hb b
   · exact fun r hr b hb => MulMemClass.mul_right_mem_add_closure hb hr
   · exact fun _ => by simp only [mul_zero, (AddSubmonoid.closure (S : Set R)).zero_mem]

As discussed on Zulip

Renames

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

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

@@ -25,8 +25,8 @@ In this file we prove various facts about membership in a submonoid:
   to an additive submonoid, then so does their sum;
 * `pow_mem`, `nsmul_mem`: if `x ∈ S` where `S` is a multiplicative (resp., additive) submonoid and
   `n` is a natural number, then `x^n` (resp., `n • x`) belongs to `S`;
-* `mem_supᵢ_of_directed`, `coe_supᵢ_of_directed`, `mem_supₛ_of_directedOn`,
-  `coe_supₛ_of_directedOn`: the supremum of a directed collection of submonoid is their union.
+* `mem_iSup_of_directed`, `coe_iSup_of_directed`, `mem_sSup_of_directedOn`,
+  `coe_sSup_of_directedOn`: the supremum of a directed collection of submonoid is their union.
 * `sup_eq_range`, `mem_sup`: supremum of two submonoids `S`, `T` of a commutative monoid is the set
   of products;
 * `closure_singleton_eq`, `mem_closure_singleton`, `mem_closure_pair`: the multiplicative (resp.,
@@ -198,40 +198,40 @@ namespace Submonoid
 -- TODO: this section can be generalized to `[SubmonoidClass B M] [CompleteLattice B]`
 -- such that `CompleteLattice.LE` coincides with `SetLike.LE`
 @[to_additive]
-theorem mem_supᵢ_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S)
+theorem mem_iSup_of_directed {ι} [hι : Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S)
     {x : M} : (x ∈ ⨆ i, S i) ↔ ∃ i, x ∈ S i := by
-  refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_supᵢ S i) hi⟩
+  refine' ⟨_, fun ⟨i, hi⟩ => (SetLike.le_def.1 <| le_iSup S i) hi⟩
   suffices x ∈ closure (⋃ i, (S i : Set M)) → ∃ i, x ∈ S i by
-    simpa only [closure_unionᵢ, closure_eq (S _)] using this
-  refine' fun hx => closure_induction hx (fun _ => mem_unionᵢ.1) _ _
+    simpa only [closure_iUnion, closure_eq (S _)] using this
+  refine' fun hx => closure_induction hx (fun _ => mem_iUnion.1) _ _
   · exact hι.elim fun i => ⟨i, (S i).one_mem⟩
   · rintro x y ⟨i, hi⟩ ⟨j, hj⟩
     rcases hS i j with ⟨k, hki, hkj⟩
     exact ⟨k, (S k).mul_mem (hki hi) (hkj hj)⟩
-#align submonoid.mem_supr_of_directed Submonoid.mem_supᵢ_of_directed
-#align add_submonoid.mem_supr_of_directed AddSubmonoid.mem_supᵢ_of_directed
+#align submonoid.mem_supr_of_directed Submonoid.mem_iSup_of_directed
+#align add_submonoid.mem_supr_of_directed AddSubmonoid.mem_iSup_of_directed
 
 @[to_additive]
-theorem coe_supᵢ_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S) :
+theorem coe_iSup_of_directed {ι} [Nonempty ι] {S : ι → Submonoid M} (hS : Directed (· ≤ ·) S) :
     ((⨆ i, S i : Submonoid M) : Set M) = ⋃ i, ↑(S i) :=
-  Set.ext fun x => by simp [mem_supᵢ_of_directed hS]
-#align submonoid.coe_supr_of_directed Submonoid.coe_supᵢ_of_directed
-#align add_submonoid.coe_supr_of_directed AddSubmonoid.coe_supᵢ_of_directed
+  Set.ext fun x => by simp [mem_iSup_of_directed hS]
+#align submonoid.coe_supr_of_directed Submonoid.coe_iSup_of_directed
+#align add_submonoid.coe_supr_of_directed AddSubmonoid.coe_iSup_of_directed
 
 @[to_additive]
-theorem mem_supₛ_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
-    (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ supₛ S ↔ ∃ s ∈ S, x ∈ s := by
+theorem mem_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
+    (hS : DirectedOn (· ≤ ·) S) {x : M} : x ∈ sSup S ↔ ∃ s ∈ S, x ∈ s := by
   haveI : Nonempty S := Sne.to_subtype
-  simp [supₛ_eq_supᵢ', mem_supᵢ_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk]
-#align submonoid.mem_Sup_of_directed_on Submonoid.mem_supₛ_of_directedOn
-#align add_submonoid.mem_Sup_of_directed_on AddSubmonoid.mem_supₛ_of_directedOn
+  simp [sSup_eq_iSup', mem_iSup_of_directed hS.directed_val, SetCoe.exists, Subtype.coe_mk]
+#align submonoid.mem_Sup_of_directed_on Submonoid.mem_sSup_of_directedOn
+#align add_submonoid.mem_Sup_of_directed_on AddSubmonoid.mem_sSup_of_directedOn
 
 @[to_additive]
-theorem coe_supₛ_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
-    (hS : DirectedOn (· ≤ ·) S) : (↑(supₛ S) : Set M) = ⋃ s ∈ S, ↑s :=
-  Set.ext fun x => by simp [mem_supₛ_of_directedOn Sne hS]
-#align submonoid.coe_Sup_of_directed_on Submonoid.coe_supₛ_of_directedOn
-#align add_submonoid.coe_Sup_of_directed_on AddSubmonoid.coe_supₛ_of_directedOn
+theorem coe_sSup_of_directedOn {S : Set (Submonoid M)} (Sne : S.Nonempty)
+    (hS : DirectedOn (· ≤ ·) S) : (↑(sSup S) : Set M) = ⋃ s ∈ S, ↑s :=
+  Set.ext fun x => by simp [mem_sSup_of_directedOn Sne hS]
+#align submonoid.coe_Sup_of_directed_on Submonoid.coe_sSup_of_directedOn
+#align add_submonoid.coe_Sup_of_directed_on AddSubmonoid.coe_sSup_of_directedOn
 
 @[to_additive]
 theorem mem_sup_left {S T : Submonoid M} : ∀ {x : M}, x ∈ S → x ∈ S ⊔ T := by
@@ -254,20 +254,20 @@ theorem mul_mem_sup {S T : Submonoid M} {x y : M} (hx : x ∈ S) (hy : y ∈ T)
 #align add_submonoid.add_mem_sup AddSubmonoid.add_mem_sup
 
 @[to_additive]
-theorem mem_supᵢ_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
-    ∀ {x : M}, x ∈ S i → x ∈ supᵢ S := by
+theorem mem_iSup_of_mem {ι : Sort _} {S : ι → Submonoid M} (i : ι) :
+    ∀ {x : M}, x ∈ S i → x ∈ iSup S := by
   rw [←SetLike.le_def]
-  exact le_supᵢ _ _
-#align submonoid.mem_supr_of_mem Submonoid.mem_supᵢ_of_mem
-#align add_submonoid.mem_supr_of_mem AddSubmonoid.mem_supᵢ_of_mem
+  exact le_iSup _ _
+#align submonoid.mem_supr_of_mem Submonoid.mem_iSup_of_mem
+#align add_submonoid.mem_supr_of_mem AddSubmonoid.mem_iSup_of_mem
 
 @[to_additive]
-theorem mem_supₛ_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
-    ∀ {x : M}, x ∈ s → x ∈ supₛ S := by
+theorem mem_sSup_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈ S) :
+    ∀ {x : M}, x ∈ s → x ∈ sSup S := by
   rw [←SetLike.le_def]
-  exact le_supₛ hs
-#align submonoid.mem_Sup_of_mem Submonoid.mem_supₛ_of_mem
-#align add_submonoid.mem_Sup_of_mem AddSubmonoid.mem_supₛ_of_mem
+  exact le_sSup hs
+#align submonoid.mem_Sup_of_mem Submonoid.mem_sSup_of_mem
+#align add_submonoid.mem_Sup_of_mem AddSubmonoid.mem_sSup_of_mem
 
 /-- An induction principle for elements of `⨆ i, S i`.
 If `C` holds for `1` and all elements of `S i` for all `i`, and is preserved under multiplication,
@@ -276,29 +276,29 @@ then it holds for all elements of the supremum of `S`. -/
       " An induction principle for elements of `⨆ i, S i`.
       If `C` holds for `0` and all elements of `S i` for all `i`, and is preserved under addition,
       then it holds for all elements of the supremum of `S`. "]
-theorem supᵢ_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
+theorem iSup_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop} {x : M} (hx : x ∈ ⨆ i, S i)
     (hp : ∀ (i), ∀ x ∈ S i, C x) (h1 : C 1) (hmul : ∀ x y, C x → C y → C (x * y)) : C x := by
-  rw [supᵢ_eq_closure] at hx
+  rw [iSup_eq_closure] at hx
   refine closure_induction hx (fun x hx => ?_) h1 hmul
-  obtain ⟨i, hi⟩ := Set.mem_unionᵢ.mp hx
+  obtain ⟨i, hi⟩ := Set.mem_iUnion.mp hx
   exact hp _ _ hi
-#align submonoid.supr_induction Submonoid.supᵢ_induction
-#align add_submonoid.supr_induction AddSubmonoid.supᵢ_induction
+#align submonoid.supr_induction Submonoid.iSup_induction
+#align add_submonoid.supr_induction AddSubmonoid.iSup_induction
 
-/-- A dependent version of `Submonoid.supᵢ_induction`. -/
-@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.supᵢ_induction`. "]
-theorem supᵢ_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
-    (hp : ∀ (i), ∀ (x) (hxS : x ∈ S i), C x (mem_supᵢ_of_mem i hxS)) (h1 : C 1 (one_mem _))
+/-- A dependent version of `Submonoid.iSup_induction`. -/
+@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.iSup_induction`. "]
+theorem iSup_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
+    (hp : ∀ (i), ∀ (x) (hxS : x ∈ S i), C x (mem_iSup_of_mem i hxS)) (h1 : C 1 (one_mem _))
     (hmul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (mul_mem ‹_› ‹_›)) {x : M}
     (hx : x ∈ ⨆ i, S i) : C x hx := by
   refine' Exists.elim (_ : ∃ Hx, C x Hx) fun (hx : x ∈ ⨆ i, S i) (hc : C x hx) => hc
-  refine' @supᵢ_induction _ _ ι S (fun m => ∃ hm, C m hm) _ hx (fun i x hx => _) _ fun x y => _
+  refine' @iSup_induction _ _ ι S (fun m => ∃ hm, C m hm) _ hx (fun i x hx => _) _ fun x y => _
   · exact ⟨_, hp _ _ hx⟩
   · exact ⟨_, h1⟩
   · rintro ⟨_, Cx⟩ ⟨_, Cy⟩
     refine' ⟨_, hmul _ _ _ _ Cx Cy⟩
-#align submonoid.supr_induction' Submonoid.supᵢ_induction'
-#align add_submonoid.supr_induction' AddSubmonoid.supᵢ_induction'
+#align submonoid.supr_induction' Submonoid.iSup_induction'
+#align add_submonoid.supr_induction' AddSubmonoid.iSup_induction'
 
 end Submonoid
 

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

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

@@ -143,8 +143,7 @@ theorem list_prod_mem {l : List M} (hl : ∀ x ∈ l, x ∈ s) : l.prod ∈ s :=
       "Sum of a multiset of elements in an `AddSubmonoid` of an `AddCommMonoid` is
       in the `AddSubmonoid`."]
 theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
-    (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S :=
-  by
+    (hm : ∀ a ∈ m, a ∈ S) : m.prod ∈ S := by
   lift m to Multiset S using hm
   rw [← coe_multiset_prod]
   exact m.prod.coe_prop
@@ -153,8 +152,7 @@ theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
 
 @[to_additive]
 theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h : ∀ x ∈ m, x ∈ S) :
-    m.noncommProd comm ∈ S :=
-  by
+    m.noncommProd comm ∈ S := by
   induction' m using Quotient.inductionOn with l
   simp only [Multiset.quot_mk_to_coe, Multiset.noncommProd_coe]
   exact Submonoid.list_prod_mem _ h
@@ -378,8 +376,7 @@ theorem exists_list_of_mem_closure {s : Set M} {x : M} (hx : x ∈ closure s) :
 
 @[to_additive]
 theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {x : M}
-    (hx : x ∈ closure s) : ∃ (l : Multiset M) (_ : ∀ y ∈ l, y ∈ s), l.prod = x :=
-  by
+    (hx : x ∈ closure s) : ∃ (l : Multiset M) (_ : ∀ y ∈ l, y ∈ s), l.prod = x := by
   obtain ⟨l, h1, h2⟩ := exists_list_of_mem_closure hx
   exact ⟨l, h1, (Multiset.coe_prod l).trans h2⟩
 #align submonoid.exists_multiset_of_mem_closure Submonoid.exists_multiset_of_mem_closure
@@ -387,8 +384,7 @@ theorem exists_multiset_of_mem_closure {M : Type _} [CommMonoid M] {s : Set M} {
 
 @[to_additive]
 theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ closure s) (H1 : p 1)
-    (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
-  by
+    (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x := by
   rw [closure_eq_mrange] at h
   obtain ⟨l, rfl⟩ := h
   induction' l using FreeMonoid.recOn with x y ih
@@ -445,8 +441,7 @@ theorem mem_powers_iff (x z : M) : x ∈ powers z ↔ ∃ n : ℕ, z ^ n = x :=
   Iff.rfl
 #align submonoid.mem_powers_iff Submonoid.mem_powers_iff
 
-theorem powers_eq_closure (n : M) : powers n = closure {n} :=
-  by
+theorem powers_eq_closure (n : M) : powers n = closure {n} := by
   ext
   exact mem_closure_singleton.symm
 #align submonoid.powers_eq_closure Submonoid.powers_eq_closure
@@ -542,8 +537,7 @@ end Submonoid
 @[to_additive]
 theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul N α] [MulAction M α]
     {s : Set M} (htop : Submonoid.closure s = ⊤)
-    (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z) : IsScalarTower M N α :=
-  by
+    (hs : ∀ x ∈ s, ∀ (y : N) (z : α), (x • y) • z = x • y • z) : IsScalarTower M N α := by
   refine' ⟨fun x => Submonoid.induction_of_closure_eq_top_left htop x _ _⟩
   · intro y z
     rw [one_smul, one_smul]
@@ -556,8 +550,7 @@ theorem IsScalarTower.of_mclosure_eq_top {N α} [Monoid M] [MulAction M N] [SMul
 @[to_additive]
 theorem SMulCommClass.of_mclosure_eq_top {N α} [Monoid M] [SMul N α] [MulAction M α] {s : Set M}
     (htop : Submonoid.closure s = ⊤) (hs : ∀ x ∈ s, ∀ (y : N) (z : α), x • y • z = y • x • z) :
-    SMulCommClass M N α :=
-  by
+    SMulCommClass M N α := by
   refine' ⟨fun x => Submonoid.induction_of_closure_eq_top_left htop x _ _⟩
   · intro y z
     rw [one_smul, one_smul]
@@ -691,8 +684,7 @@ elements. -/
       "An element is in the closure of a two-element set if it is a linear combination of
       those two elements."]
 theorem mem_closure_pair {A : Type _} [CommMonoid A] (a b c : A) :
-    c ∈ Submonoid.closure ({a, b} : Set A) ↔ ∃ m n : ℕ, a ^ m * b ^ n = c :=
-  by
+    c ∈ Submonoid.closure ({a, b} : Set A) ↔ ∃ m n : ℕ, a ^ m * b ^ n = c := by
   rw [← Set.singleton_union, Submonoid.closure_union, mem_sup]
   simp_rw [mem_closure_singleton, exists_exists_eq_and]
 #align submonoid.mem_closure_pair Submonoid.mem_closure_pair

closes #3680, see https://leanprover.zulipchat.com/#narrow/stream/287929-mathlib4/topic/Stepping.20through.20simp_rw/near/326712986

@@ -694,7 +694,7 @@ theorem mem_closure_pair {A : Type _} [CommMonoid A] (a b c : A) :
     c ∈ Submonoid.closure ({a, b} : Set A) ↔ ∃ m n : ℕ, a ^ m * b ^ n = c :=
   by
   rw [← Set.singleton_union, Submonoid.closure_union, mem_sup]
-  simp_rw [exists_prop, mem_closure_singleton, exists_exists_eq_and]
+  simp_rw [mem_closure_singleton, exists_exists_eq_and]
 #align submonoid.mem_closure_pair Submonoid.mem_closure_pair
 #align add_submonoid.mem_closure_pair AddSubmonoid.mem_closure_pair
 

This PR fixes two things:

• Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
• All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

@@ -425,8 +425,7 @@ theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : clo
     (by rw [hs]; exact mem_top _)
     H1 Hmul
 #align submonoid.induction_of_closure_eq_top_right Submonoid.induction_of_closure_eq_top_right
-#align add_submonoid.induction_of_closure_eq_top_right
-  AddSubmonoid.induction_of_closure_eq_top_right
+#align add_submonoid.induction_of_closure_eq_top_right AddSubmonoid.induction_of_closure_eq_top_right
 
 /-- The submonoid generated by an element. -/
 def powers (n : M) : Submonoid M :=
@@ -485,8 +484,7 @@ theorem pow_log_eq_self [DecidableEq M] {n : M} (p : powers n) : pow n (log p) =
 theorem pow_right_injective_iff_pow_injective {n : M} :
     (Function.Injective fun m : ℕ => n ^ m) ↔ Function.Injective (pow n) :=
   Subtype.coe_injective.of_comp_iff (pow n)
-#align submonoid.pow_right_injective_iff_pow_injective
-  Submonoid.pow_right_injective_iff_pow_injective
+#align submonoid.pow_right_injective_iff_pow_injective Submonoid.pow_right_injective_iff_pow_injective
 
 @[simp]
 theorem log_pow_eq_self [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)

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

• algebra.group_power.lemmas@05101c3df9d9cfe9430edc205860c79b6d660102..e655e4ea5c6d02854696f97494997ba4c31be802
• group_theory.submonoid.membership@2ec920d35348cb2d13ac0e1a2ad9df0fdf1a76b4..e655e4ea5c6d02854696f97494997ba4c31be802
• group_theory.subgroup.zpowers@f93c11933efbc3c2f0299e47b8ff83e9b539cbf6..e655e4ea5c6d02854696f97494997ba4c31be802
• group_theory.subgroup.pointwise@c10e724be91096453ee3db13862b9fb9a992fef2..e655e4ea5c6d02854696f97494997ba4c31be802
• ring_theory.int.basic@2196ab363eb097c008d4497125e0dde23fb36db2..e655e4ea5c6d02854696f97494997ba4c31be802

@@ -5,7 +5,7 @@ Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzza
 Amelia Livingston, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module group_theory.submonoid.membership
-! leanprover-community/mathlib commit 2ec920d35348cb2d13ac0e1a2ad9df0fdf1a76b4
+! leanprover-community/mathlib commit e655e4ea5c6d02854696f97494997ba4c31be802
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -438,6 +438,10 @@ theorem mem_powers (n : M) : n ∈ powers n :=
   ⟨1, pow_one _⟩
 #align submonoid.mem_powers Submonoid.mem_powers
 
+theorem coe_powers (x : M) : ↑(powers x) = Set.range fun n : ℕ => x ^ n :=
+  rfl
+#align submonoid.coe_powers Submonoid.coe_powers
+
 theorem mem_powers_iff (x z : M) : x ∈ powers z ↔ ∃ n : ℕ, z ^ n = x :=
   Iff.rfl
 #align submonoid.mem_powers_iff Submonoid.mem_powers_iff
@@ -620,6 +624,9 @@ attribute [to_additive existing multiples] Submonoid.powers
 attribute [to_additive (attr := simp) mem_multiples] Submonoid.mem_powers
 #align add_submonoid.mem_multiples AddSubmonoid.mem_multiples
 
+attribute [to_additive (attr := norm_cast) coe_multiples] Submonoid.coe_powers
+#align add_submonoid.coe_multiples AddSubmonoid.coe_multiples
+
 attribute [to_additive mem_multiples_iff] Submonoid.mem_powers_iff
 #align add_submonoid.mem_multiples_iff AddSubmonoid.mem_multiples_iff
 

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

@@ -5,7 +5,7 @@ Authors: Johannes Hölzl, Kenny Lau, Johan Commelin, Mario Carneiro, Kevin Buzza
 Amelia Livingston, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module group_theory.submonoid.membership
-! leanprover-community/mathlib commit 509de852e1de55e1efa8eacfa11df0823f26f226
+! leanprover-community/mathlib commit 2ec920d35348cb2d13ac0e1a2ad9df0fdf1a76b4
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -364,7 +364,7 @@ theorem closure_eq_mrange (s : Set M) : closure s = mrange (FreeMonoid.lift ((
 @[to_additive]
 theorem closure_eq_image_prod (s : Set M) :
     (closure s : Set M) = List.prod '' { l : List M | ∀ x ∈ l, x ∈ s } := by
-  rw [closure_eq_mrange, coe_mrange, ← List.range_map_coe, ← Set.range_comp]
+  rw [closure_eq_mrange, coe_mrange, ← Set.range_list_map_coe, ← Set.range_comp]
   exact congrArg _ (funext <| FreeMonoid.lift_apply _)
 #align submonoid.closure_eq_image_prod Submonoid.closure_eq_image_prod
 #align add_submonoid.closure_eq_image_sum AddSubmonoid.closure_eq_image_sum

@@ -274,8 +274,7 @@ theorem mem_supₛ_of_mem {S : Set (Submonoid M)} {s : Submonoid M} (hs : s ∈
 /-- An induction principle for elements of `⨆ i, S i`.
 If `C` holds for `1` and all elements of `S i` for all `i`, and is preserved under multiplication,
 then it holds for all elements of the supremum of `S`. -/
-@[elab_as_elim,
-  to_additive
+@[to_additive (attr := elab_as_elim)
       " An induction principle for elements of `⨆ i, S i`.
       If `C` holds for `0` and all elements of `S i` for all `i`, and is preserved under addition,
       then it holds for all elements of the supremum of `S`. "]
@@ -289,7 +288,7 @@ theorem supᵢ_induction {ι : Sort _} (S : ι → Submonoid M) {C : M → Prop}
 #align add_submonoid.supr_induction AddSubmonoid.supᵢ_induction
 
 /-- A dependent version of `Submonoid.supᵢ_induction`. -/
-@[elab_as_elim, to_additive "A dependent version of `AddSubmonoid.supᵢ_induction`. "]
+@[to_additive (attr := elab_as_elim) "A dependent version of `AddSubmonoid.supᵢ_induction`. "]
 theorem supᵢ_induction' {ι : Sort _} (S : ι → Submonoid M) {C : ∀ x, (x ∈ ⨆ i, S i) → Prop}
     (hp : ∀ (i), ∀ (x) (hxS : x ∈ S i), C x (mem_supᵢ_of_mem i hxS)) (h1 : C 1 (one_mem _))
     (hmul : ∀ x y hx hy, C x hx → C y hy → C (x * y) (mul_mem ‹_› ‹_›)) {x : M}
@@ -398,7 +397,7 @@ theorem closure_induction_left {s : Set M} {p : M → Prop} {x : M} (h : x ∈ c
 #align submonoid.closure_induction_left Submonoid.closure_induction_left
 #align add_submonoid.closure_induction_left AddSubmonoid.closure_induction_left
 
-@[elab_as_elim, to_additive]
+@[to_additive (attr := elab_as_elim)]
 theorem induction_of_closure_eq_top_left {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ x ∈ s, ∀ (y), p y → p (x * y)) : p x :=
   closure_induction_left
@@ -419,7 +418,7 @@ theorem closure_induction_right {s : Set M} {p : M → Prop} {x : M} (h : x ∈
 #align submonoid.closure_induction_right Submonoid.closure_induction_right
 #align add_submonoid.closure_induction_right AddSubmonoid.closure_induction_right
 
-@[elab_as_elim, to_additive]
+@[to_additive (attr := elab_as_elim)]
 theorem induction_of_closure_eq_top_right {s : Set M} {p : M → Prop} (hs : closure s = ⊤) (x : M)
     (H1 : p 1) (Hmul : ∀ (x), ∀ y ∈ s, p x → p (x * y)) : p x :=
   closure_induction_right

@@ -502,7 +502,7 @@ def powLogEquiv [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n
   right_inv := pow_log_eq_self
   map_mul' _ _ := by simp only [pow, map_mul, ofAdd_add, toAdd_mul]
 #align submonoid.pow_log_equiv Submonoid.powLogEquiv
-#align submonoid.pow_log_equiv_symm_apply Submonoid.powLogEquiv_symmApply
+#align submonoid.pow_log_equiv_symm_apply Submonoid.powLogEquiv_symm_apply
 #align submonoid.pow_log_equiv_apply Submonoid.powLogEquiv_apply
 
 theorem log_mul [DecidableEq M] {n : M} (h : Function.Injective fun m : ℕ => n ^ m)

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

@@ -616,7 +616,7 @@ def multiples (x : A) : AddSubmonoid A :=
     Set.ext fun n => exists_congr fun i => by simp
 #align add_submonoid.multiples AddSubmonoid.multiples
 
-attribute [to_additive multiples] Submonoid.powers
+attribute [to_additive existing multiples] Submonoid.powers
 
 attribute [to_additive (attr := simp) mem_multiples] Submonoid.mem_powers
 #align add_submonoid.mem_multiples AddSubmonoid.mem_multiples

• This does not change the behavior of simps, just raises a linter error if you run simps in a more expensive mode without writing !.
• Fixed some incorrect occurrences of to_additive, simps. Will do that systematically in future PR.
• Fix port of OmegaCompletePartialOrder.ContinuousHom.ofMono a bit

Co-authored-by: Yury G. Kudryashov <urkud@urkud.name>

@@ -459,7 +459,7 @@ theorem powers_one : powers (1 : M) = ⊥ :=
 #align submonoid.powers_one Submonoid.powers_one
 
 /-- Exponentiation map from natural numbers to powers. -/
-@[simps]
+@[simps!]
 def pow (n : M) (m : ℕ) : powers n :=
   (powersHom M n).mrangeRestrict (Multiplicative.ofAdd m)
 #align submonoid.pow Submonoid.pow

@@ -37,8 +37,7 @@ In this file we prove various facts about membership in a submonoid:
 submonoid, submonoids
 -/
 
--- Porting note: big operators are currently global
---open BigOperators
+open BigOperators
 
 variable {M A B : Type _}
 

As seen in #1864, but I was too slow.

@@ -153,14 +153,14 @@ theorem multiset_prod_mem {M} [CommMonoid M] (S : Submonoid M) (m : Multiset M)
 #align add_submonoid.multiset_sum_mem AddSubmonoid.multiset_sum_mem
 
 @[to_additive]
-theorem multiset_noncomm_prod_mem (S : Submonoid M) (m : Multiset M) (comm) (h : ∀ x ∈ m, x ∈ S) :
+theorem multiset_noncommProd_mem (S : Submonoid M) (m : Multiset M) (comm) (h : ∀ x ∈ m, x ∈ S) :
     m.noncommProd comm ∈ S :=
   by
   induction' m using Quotient.inductionOn with l
   simp only [Multiset.quot_mk_to_coe, Multiset.noncommProd_coe]
   exact Submonoid.list_prod_mem _ h
-#align submonoid.multiset_noncomm_prod_mem Submonoid.multiset_noncomm_prod_mem
-#align add_submonoid.multiset_noncomm_sum_mem AddSubmonoid.multiset_noncomm_sum_mem
+#align submonoid.multiset_noncomm_prod_mem Submonoid.multiset_noncommProd_mem
+#align add_submonoid.multiset_noncomm_sum_mem AddSubmonoid.multiset_noncommSum_mem
 
 /-- Product of elements of a submonoid of a `CommMonoid` indexed by a `Finset` is in the
     submonoid. -/
@@ -176,15 +176,15 @@ theorem prod_mem {M : Type _} [CommMonoid M] (S : Submonoid M) {ι : Type _} {t
 #align add_submonoid.sum_mem AddSubmonoid.sum_mem
 
 @[to_additive]
-theorem noncomm_prod_mem (S : Submonoid M) {ι : Type _} (t : Finset ι) (f : ι → M) (comm)
+theorem noncommProd_mem (S : Submonoid M) {ι : Type _} (t : Finset ι) (f : ι → M) (comm)
     (h : ∀ c ∈ t, f c ∈ S) : t.noncommProd f comm ∈ S := by
-  apply multiset_noncomm_prod_mem
+  apply multiset_noncommProd_mem
   intro y
   rw [Multiset.mem_map]
   rintro ⟨x, ⟨hx, rfl⟩⟩
   exact h x hx
-#align submonoid.noncomm_prod_mem Submonoid.noncomm_prod_mem
-#align add_submonoid.noncomm_sum_mem AddSubmonoid.noncomm_sum_mem
+#align submonoid.noncomm_prod_mem Submonoid.noncommProd_mem
+#align add_submonoid.noncomm_sum_mem AddSubmonoid.noncommSum_mem
 
 end Submonoid
 

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

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