group_theory.submonoid.pointwise ⟷ Mathlib.GroupTheory.Submonoid.Pointwise

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

@@ -3,7 +3,7 @@ Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Data.Set.Pointwise.Smul
+import Data.Set.Pointwise.SMul
 import GroupTheory.Submonoid.Membership
 import Order.WellFoundedSet
 
@@ -856,7 +856,7 @@ instance : Monoid (AddSubmonoid R) :=
 #print AddSubmonoid.closure_pow /-
 theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)
   | 0 => by rw [pow_zero, pow_zero, one_eq_closure_one_set]
-  | n + 1 => by rw [pow_succ, pow_succ, closure_pow, closure_mul_closure]
+  | n + 1 => by rw [pow_succ', pow_succ', closure_pow, closure_mul_closure]
 #align add_submonoid.closure_pow AddSubmonoid.closure_pow
 -/
 

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

@@ -876,21 +876,21 @@ end Semiring
 
 end AddSubmonoid
 
-namespace Set.IsPwo
+namespace Set.IsPWO
 
 variable [OrderedCancelCommMonoid α] {s : Set α}
 
-#print Set.IsPwo.submonoid_closure /-
+#print Set.IsPWO.submonoid_closure /-
 @[to_additive]
-theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPwo) :
-    IsPwo (Submonoid.closure s : Set α) :=
+theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPWO) :
+    IsPWO (Submonoid.closure s : Set α) :=
   by
   rw [Submonoid.closure_eq_image_prod]
   refine' (h.partially_well_ordered_on_sublist_forall₂ (· ≤ ·)).image_of_monotone_on _
   exact fun l1 hl1 l2 hl2 h12 => h12.prod_le_prod' fun x hx => hpos x <| hl2 x hx
-#align set.is_pwo.submonoid_closure Set.IsPwo.submonoid_closure
-#align set.is_pwo.add_submonoid_closure Set.IsPwo.addSubmonoid_closure
+#align set.is_pwo.submonoid_closure Set.IsPWO.submonoid_closure
+#align set.is_pwo.add_submonoid_closure Set.IsPWO.addSubmonoid_closure
 -/
 
-end Set.IsPwo
+end Set.IsPWO
 

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

@@ -101,15 +101,15 @@ theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure
 #align add_submonoid.closure_add_le AddSubmonoid.closure_add_le
 -/
 
-#print Submonoid.sup_eq_closure /-
+#print Submonoid.sup_eq_closure_mul /-
 @[to_additive]
-theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure (H * K) :=
+theorem sup_eq_closure_mul (H K : Submonoid M) : H ⊔ K = closure (H * K) :=
   le_antisymm
     (sup_le (fun h hh => subset_closure ⟨h, 1, hh, K.one_mem, mul_one h⟩) fun k hk =>
       subset_closure ⟨1, k, H.one_mem, hk, one_mul k⟩)
     (by conv_rhs => rw [← closure_eq H, ← closure_eq K] <;> apply closure_mul_le)
-#align submonoid.sup_eq_closure Submonoid.sup_eq_closure
-#align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure
+#align submonoid.sup_eq_closure Submonoid.sup_eq_closure_mul
+#align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure_add
 -/
 
 #print Submonoid.pow_smul_mem_closure_smul /-

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

@@ -3,9 +3,9 @@ Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
-import Mathbin.Data.Set.Pointwise.Smul
-import Mathbin.GroupTheory.Submonoid.Membership
-import Mathbin.Order.WellFoundedSet
+import Data.Set.Pointwise.Smul
+import GroupTheory.Submonoid.Membership
+import Order.WellFoundedSet
 
 #align_import group_theory.submonoid.pointwise from "leanprover-community/mathlib"@"2bbc7e3884ba234309d2a43b19144105a753292e"
 

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

@@ -95,7 +95,7 @@ theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s :=
 theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T :=
   sInf_le fun x ⟨s, t, hs, ht, hx⟩ =>
     hx ▸
-      (closure S ⊔ closure T).mul_mem (SetLike.le_def.mp le_sup_left <| subset_closure hs)
+      (closure S ⊔ closure T).hMul_mem (SetLike.le_def.mp le_sup_left <| subset_closure hs)
         (SetLike.le_def.mp le_sup_right <| subset_closure ht)
 #align submonoid.closure_mul_le Submonoid.closure_mul_le
 #align add_submonoid.closure_add_le AddSubmonoid.closure_add_le
@@ -140,7 +140,7 @@ protected def inv : Inv (Submonoid G)
     where inv S :=
     { carrier := (S : Set G)⁻¹
       one_mem' := show (1 : G)⁻¹ ∈ S by rw [inv_one]; exact S.one_mem
-      mul_mem' := fun a b (ha : a⁻¹ ∈ S) (hb : b⁻¹ ∈ S) =>
+      hMul_mem' := fun a b (ha : a⁻¹ ∈ S) (hb : b⁻¹ ∈ S) =>
         show (a * b)⁻¹ ∈ S by rw [mul_inv_rev]; exact S.mul_mem hb ha }
 #align submonoid.has_inv Submonoid.inv
 #align add_submonoid.has_neg AddSubmonoid.neg
@@ -274,7 +274,7 @@ protected def pointwiseMulAction : MulAction α (Submonoid M)
     where
   smul a S := S.map (MulDistribMulAction.toMonoidEnd _ M a)
   one_smul S := by ext; simp
-  mul_smul a₁ a₂ S :=
+  hMul_smul a₁ a₂ S :=
     (congr_arg (fun f : Monoid.End M => S.map f) (MonoidHom.map_mul _ _ _)).trans
       (S.map_map _ _).symm
 #align submonoid.pointwise_mul_action Submonoid.pointwiseMulAction
@@ -456,7 +456,7 @@ protected def pointwiseMulAction : MulAction α (AddSubmonoid A)
   smul a S := S.map (DistribMulAction.toAddMonoidEnd _ A a)
   one_smul S :=
     (congr_arg (fun f : AddMonoid.End A => S.map f) (MonoidHom.map_one _)).trans S.map_id
-  mul_smul a₁ a₂ S :=
+  hMul_smul a₁ a₂ S :=
     (congr_arg (fun f : AddMonoid.End A => S.map f) (MonoidHom.map_mul _ _ _)).trans
       (S.map_map _ _).symm
 #align add_submonoid.pointwise_mul_action AddSubmonoid.pointwiseMulAction
@@ -788,7 +788,7 @@ This is available as an instance in the `pointwise` locale. -/
 protected def hasDistribNeg : HasDistribNeg (AddSubmonoid R) :=
   { AddSubmonoid.hasInvolutiveNeg with
     neg := Neg.neg
-    neg_mul := fun x y =>
+    neg_hMul := fun x y =>
       by
       refine'
           le_antisymm (mul_le.2 fun m hm n hn => _)
@@ -796,7 +796,7 @@ protected def hasDistribNeg : HasDistribNeg (AddSubmonoid R) :=
         simp only [AddSubmonoid.mem_neg, ← neg_mul] at *
       · exact mul_mem_mul hm hn
       · exact mul_mem_mul (neg_mem_neg.2 hm) hn
-    mul_neg := fun x y =>
+    hMul_neg := fun x y =>
       by
       refine'
           le_antisymm (mul_le.2 fun m hm n hn => _)

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

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module group_theory.submonoid.pointwise
-! leanprover-community/mathlib commit 2bbc7e3884ba234309d2a43b19144105a753292e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Set.Pointwise.Smul
 import Mathbin.GroupTheory.Submonoid.Membership
 import Mathbin.Order.WellFoundedSet
 
+#align_import group_theory.submonoid.pointwise from "leanprover-community/mathlib"@"2bbc7e3884ba234309d2a43b19144105a753292e"
+
 /-! # Pointwise instances on `submonoid`s and `add_submonoid`s
 
 > THIS FILE IS SYNCHRONIZED WITH MATHLIB4.

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

@@ -65,18 +65,23 @@ open scoped Pointwise
 
 variable {s t u : Set M}
 
+#print Submonoid.mul_subset /-
 @[to_additive]
 theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S := by
   rintro _ ⟨p, q, hp, hq, rfl⟩; exact Submonoid.mul_mem _ (hs hp) (ht hq)
 #align submonoid.mul_subset Submonoid.mul_subset
 #align add_submonoid.add_subset AddSubmonoid.add_subset
+-/
 
+#print Submonoid.mul_subset_closure /-
 @[to_additive]
 theorem mul_subset_closure (hs : s ⊆ u) (ht : t ⊆ u) : s * t ⊆ Submonoid.closure u :=
   mul_subset (Subset.trans hs Submonoid.subset_closure) (Subset.trans ht Submonoid.subset_closure)
 #align submonoid.mul_subset_closure Submonoid.mul_subset_closure
 #align add_submonoid.add_subset_closure AddSubmonoid.add_subset_closure
+-/
 
+#print Submonoid.coe_mul_self_eq /-
 @[to_additive]
 theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s :=
   by
@@ -86,7 +91,9 @@ theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s :=
   exact s.mul_mem ha hb
 #align submonoid.coe_mul_self_eq Submonoid.coe_mul_self_eq
 #align add_submonoid.coe_add_self_eq AddSubmonoid.coe_add_self_eq
+-/
 
+#print Submonoid.closure_mul_le /-
 @[to_additive]
 theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T :=
   sInf_le fun x ⟨s, t, hs, ht, hx⟩ =>
@@ -95,7 +102,9 @@ theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure
         (SetLike.le_def.mp le_sup_right <| subset_closure ht)
 #align submonoid.closure_mul_le Submonoid.closure_mul_le
 #align add_submonoid.closure_add_le AddSubmonoid.closure_add_le
+-/
 
+#print Submonoid.sup_eq_closure /-
 @[to_additive]
 theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure (H * K) :=
   le_antisymm
@@ -104,7 +113,9 @@ theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure (H * K) :=
     (by conv_rhs => rw [← closure_eq H, ← closure_eq K] <;> apply closure_mul_le)
 #align submonoid.sup_eq_closure Submonoid.sup_eq_closure
 #align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure
+-/
 
+#print Submonoid.pow_smul_mem_closure_smul /-
 @[to_additive]
 theorem pow_smul_mem_closure_smul {N : Type _} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]
     (r : M) (s : Set N) {x : N} (hx : x ∈ closure s) : ∃ n : ℕ, r ^ n • x ∈ closure (r • s) :=
@@ -119,6 +130,7 @@ theorem pow_smul_mem_closure_smul {N : Type _} [CommMonoid N] [MulAction M N] [I
     rw [pow_add, smul_mul_assoc, mul_smul, mul_comm, ← smul_mul_assoc, mul_comm]
 #align submonoid.pow_smul_mem_closure_smul Submonoid.pow_smul_mem_closure_smul
 #align add_submonoid.nsmul_vadd_mem_closure_vadd AddSubmonoid.nsmul_vadd_mem_closure_vadd
+-/
 
 variable [Group G]
 
@@ -141,34 +153,43 @@ scoped[Pointwise] attribute [instance] Submonoid.inv
 
 open scoped Pointwise
 
+#print Submonoid.coe_inv /-
 @[simp, to_additive]
 theorem coe_inv (S : Submonoid G) : ↑S⁻¹ = (S : Set G)⁻¹ :=
   rfl
 #align submonoid.coe_inv Submonoid.coe_inv
 #align add_submonoid.coe_neg AddSubmonoid.coe_neg
+-/
 
+#print Submonoid.mem_inv /-
 @[simp, to_additive]
 theorem mem_inv {g : G} {S : Submonoid G} : g ∈ S⁻¹ ↔ g⁻¹ ∈ S :=
   Iff.rfl
 #align submonoid.mem_inv Submonoid.mem_inv
 #align add_submonoid.mem_neg AddSubmonoid.mem_neg
+-/
 
 @[to_additive]
 instance : InvolutiveInv (Submonoid G) :=
   SetLike.coe_injective.InvolutiveInv _ fun _ => rfl
 
+#print Submonoid.inv_le_inv /-
 @[simp, to_additive]
 theorem inv_le_inv (S T : Submonoid G) : S⁻¹ ≤ T⁻¹ ↔ S ≤ T :=
   SetLike.coe_subset_coe.symm.trans Set.inv_subset_inv
 #align submonoid.inv_le_inv Submonoid.inv_le_inv
 #align add_submonoid.neg_le_neg AddSubmonoid.neg_le_neg
+-/
 
+#print Submonoid.inv_le /-
 @[to_additive]
 theorem inv_le (S T : Submonoid G) : S⁻¹ ≤ T ↔ S ≤ T⁻¹ :=
   SetLike.coe_subset_coe.symm.trans Set.inv_subset
 #align submonoid.inv_le Submonoid.inv_le
 #align add_submonoid.neg_le AddSubmonoid.neg_le
+-/
 
+#print Submonoid.invOrderIso /-
 /-- `submonoid.has_inv` as an order isomorphism. -/
 @[to_additive " `add_submonoid.has_neg` as an order isomorphism ", simps]
 def invOrderIso : Submonoid G ≃o Submonoid G
@@ -177,7 +198,9 @@ def invOrderIso : Submonoid G ≃o Submonoid G
   map_rel_iff' := inv_le_inv
 #align submonoid.inv_order_iso Submonoid.invOrderIso
 #align add_submonoid.neg_order_iso AddSubmonoid.negOrderIso
+-/
 
+#print Submonoid.closure_inv /-
 @[to_additive]
 theorem closure_inv (s : Set G) : closure s⁻¹ = (closure s)⁻¹ :=
   by
@@ -188,30 +211,39 @@ theorem closure_inv (s : Set G) : closure s⁻¹ = (closure s)⁻¹ :=
     exact subset_closure
 #align submonoid.closure_inv Submonoid.closure_inv
 #align add_submonoid.closure_neg AddSubmonoid.closure_neg
+-/
 
+#print Submonoid.inv_inf /-
 @[simp, to_additive]
 theorem inv_inf (S T : Submonoid G) : (S ⊓ T)⁻¹ = S⁻¹ ⊓ T⁻¹ :=
   SetLike.coe_injective Set.inter_inv
 #align submonoid.inv_inf Submonoid.inv_inf
 #align add_submonoid.neg_inf AddSubmonoid.neg_inf
+-/
 
+#print Submonoid.inv_sup /-
 @[simp, to_additive]
 theorem inv_sup (S T : Submonoid G) : (S ⊔ T)⁻¹ = S⁻¹ ⊔ T⁻¹ :=
   (invOrderIso : Submonoid G ≃o Submonoid G).map_sup S T
 #align submonoid.inv_sup Submonoid.inv_sup
 #align add_submonoid.neg_sup AddSubmonoid.neg_sup
+-/
 
+#print Submonoid.inv_bot /-
 @[simp, to_additive]
 theorem inv_bot : (⊥ : Submonoid G)⁻¹ = ⊥ :=
   SetLike.coe_injective <| (Set.inv_singleton 1).trans <| congr_arg _ inv_one
 #align submonoid.inv_bot Submonoid.inv_bot
 #align add_submonoid.neg_bot AddSubmonoid.neg_bot
+-/
 
+#print Submonoid.inv_top /-
 @[simp, to_additive]
 theorem inv_top : (⊤ : Submonoid G)⁻¹ = ⊤ :=
   SetLike.coe_injective <| Set.inv_univ
 #align submonoid.inv_top Submonoid.inv_top
 #align add_submonoid.neg_top AddSubmonoid.neg_top
+-/
 
 #print Submonoid.inv_iInf /-
 @[simp, to_additive]
@@ -221,11 +253,13 @@ theorem inv_iInf {ι : Sort _} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = 
 #align add_submonoid.neg_infi AddSubmonoid.neg_iInf
 -/
 
+#print Submonoid.inv_iSup /-
 @[simp, to_additive]
 theorem inv_iSup {ι : Sort _} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
   (invOrderIso : Submonoid G ≃o Submonoid G).map_iSup _
 #align submonoid.inv_supr Submonoid.inv_iSup
 #align add_submonoid.neg_supr AddSubmonoid.neg_iSup
+-/
 
 end Submonoid
 
@@ -253,28 +287,38 @@ scoped[Pointwise] attribute [instance] Submonoid.pointwiseMulAction
 
 open scoped Pointwise
 
+#print Submonoid.coe_pointwise_smul /-
 @[simp]
 theorem coe_pointwise_smul (a : α) (S : Submonoid M) : ↑(a • S) = a • (S : Set M) :=
   rfl
 #align submonoid.coe_pointwise_smul Submonoid.coe_pointwise_smul
+-/
 
+#print Submonoid.smul_mem_pointwise_smul /-
 theorem smul_mem_pointwise_smul (m : M) (a : α) (S : Submonoid M) : m ∈ S → a • m ∈ a • S :=
   (Set.smul_mem_smul_set : _ → _ ∈ a • (S : Set M))
 #align submonoid.smul_mem_pointwise_smul Submonoid.smul_mem_pointwise_smul
+-/
 
+#print Submonoid.mem_smul_pointwise_iff_exists /-
 theorem mem_smul_pointwise_iff_exists (m : M) (a : α) (S : Submonoid M) :
     m ∈ a • S ↔ ∃ s : M, s ∈ S ∧ a • s = m :=
   (Set.mem_smul_set : m ∈ a • (S : Set M) ↔ _)
 #align submonoid.mem_smul_pointwise_iff_exists Submonoid.mem_smul_pointwise_iff_exists
+-/
 
+#print Submonoid.smul_bot /-
 @[simp]
 theorem smul_bot (a : α) : a • (⊥ : Submonoid M) = ⊥ :=
   map_bot _
 #align submonoid.smul_bot Submonoid.smul_bot
+-/
 
+#print Submonoid.smul_sup /-
 theorem smul_sup (a : α) (S T : Submonoid M) : a • (S ⊔ T) = a • S ⊔ a • T :=
   map_sup _ _ _
 #align submonoid.smul_sup Submonoid.smul_sup
+-/
 
 #print Submonoid.smul_closure /-
 theorem smul_closure (a : α) (s : Set M) : a • closure s = closure (a • s) :=
@@ -282,10 +326,12 @@ theorem smul_closure (a : α) (s : Set M) : a • closure s = closure (a • s)
 #align submonoid.smul_closure Submonoid.smul_closure
 -/
 
+#print Submonoid.pointwise_isCentralScalar /-
 instance pointwise_isCentralScalar [MulDistribMulAction αᵐᵒᵖ M] [IsCentralScalar α M] :
     IsCentralScalar α (Submonoid M) :=
   ⟨fun a S => (congr_arg fun f : Monoid.End M => S.map f) <| MonoidHom.ext <| op_smul_eq_smul _⟩
 #align submonoid.pointwise_central_scalar Submonoid.pointwise_isCentralScalar
+-/
 
 end Monoid
 
@@ -295,32 +341,44 @@ variable [Group α] [MulDistribMulAction α M]
 
 open scoped Pointwise
 
+#print Submonoid.smul_mem_pointwise_smul_iff /-
 @[simp]
 theorem smul_mem_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff
 #align submonoid.smul_mem_pointwise_smul_iff Submonoid.smul_mem_pointwise_smul_iff
+-/
 
+#print Submonoid.mem_pointwise_smul_iff_inv_smul_mem /-
 theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : Submonoid M} {x : M} :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem
 #align submonoid.mem_pointwise_smul_iff_inv_smul_mem Submonoid.mem_pointwise_smul_iff_inv_smul_mem
+-/
 
+#print Submonoid.mem_inv_pointwise_smul_iff /-
 theorem mem_inv_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff
 #align submonoid.mem_inv_pointwise_smul_iff Submonoid.mem_inv_pointwise_smul_iff
+-/
 
+#print Submonoid.pointwise_smul_le_pointwise_smul_iff /-
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : Submonoid M} : a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff
 #align submonoid.pointwise_smul_le_pointwise_smul_iff Submonoid.pointwise_smul_le_pointwise_smul_iff
+-/
 
+#print Submonoid.pointwise_smul_subset_iff /-
 theorem pointwise_smul_subset_iff {a : α} {S T : Submonoid M} : a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff
 #align submonoid.pointwise_smul_subset_iff Submonoid.pointwise_smul_subset_iff
+-/
 
+#print Submonoid.subset_pointwise_smul_iff /-
 theorem subset_pointwise_smul_iff {a : α} {S T : Submonoid M} : S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff
 #align submonoid.subset_pointwise_smul_iff Submonoid.subset_pointwise_smul_iff
+-/
 
 end Group
 
@@ -330,45 +388,59 @@ variable [GroupWithZero α] [MulDistribMulAction α M]
 
 open scoped Pointwise
 
+#print Submonoid.smul_mem_pointwise_smul_iff₀ /-
 @[simp]
 theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
     a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff₀ ha (S : Set M) x
 #align submonoid.smul_mem_pointwise_smul_iff₀ Submonoid.smul_mem_pointwise_smul_iff₀
+-/
 
+#print Submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ /-
 theorem mem_pointwise_smul_iff_inv_smul_mem₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem₀ ha (S : Set M) x
 #align submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ Submonoid.mem_pointwise_smul_iff_inv_smul_mem₀
+-/
 
+#print Submonoid.mem_inv_pointwise_smul_iff₀ /-
 theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
     x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff₀ ha (S : Set M) x
 #align submonoid.mem_inv_pointwise_smul_iff₀ Submonoid.mem_inv_pointwise_smul_iff₀
+-/
 
+#print Submonoid.pointwise_smul_le_pointwise_smul_iff₀ /-
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} :
     a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff₀ ha
 #align submonoid.pointwise_smul_le_pointwise_smul_iff₀ Submonoid.pointwise_smul_le_pointwise_smul_iff₀
+-/
 
+#print Submonoid.pointwise_smul_le_iff₀ /-
 theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff₀ ha
 #align submonoid.pointwise_smul_le_iff₀ Submonoid.pointwise_smul_le_iff₀
+-/
 
+#print Submonoid.le_pointwise_smul_iff₀ /-
 theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff₀ ha
 #align submonoid.le_pointwise_smul_iff₀ Submonoid.le_pointwise_smul_iff₀
+-/
 
 end GroupWithZero
 
 open scoped Pointwise
 
+#print Submonoid.mem_closure_inv /-
 @[to_additive]
 theorem mem_closure_inv {G : Type _} [Group G] (S : Set G) (x : G) :
     x ∈ Submonoid.closure S⁻¹ ↔ x⁻¹ ∈ Submonoid.closure S := by rw [closure_inv, mem_inv]
 #align submonoid.mem_closure_inv Submonoid.mem_closure_inv
 #align add_submonoid.mem_closure_neg AddSubmonoid.mem_closure_neg
+-/
 
 end Submonoid
 
@@ -397,39 +469,53 @@ scoped[Pointwise] attribute [instance] AddSubmonoid.pointwiseMulAction
 
 open scoped Pointwise
 
+#print AddSubmonoid.coe_pointwise_smul /-
 @[simp]
 theorem coe_pointwise_smul (a : α) (S : AddSubmonoid A) : ↑(a • S) = a • (S : Set A) :=
   rfl
 #align add_submonoid.coe_pointwise_smul AddSubmonoid.coe_pointwise_smul
+-/
 
+#print AddSubmonoid.smul_mem_pointwise_smul /-
 theorem smul_mem_pointwise_smul (m : A) (a : α) (S : AddSubmonoid A) : m ∈ S → a • m ∈ a • S :=
   (Set.smul_mem_smul_set : _ → _ ∈ a • (S : Set A))
 #align add_submonoid.smul_mem_pointwise_smul AddSubmonoid.smul_mem_pointwise_smul
+-/
 
+#print AddSubmonoid.mem_smul_pointwise_iff_exists /-
 theorem mem_smul_pointwise_iff_exists (m : A) (a : α) (S : AddSubmonoid A) :
     m ∈ a • S ↔ ∃ s : A, s ∈ S ∧ a • s = m :=
   (Set.mem_smul_set : m ∈ a • (S : Set A) ↔ _)
 #align add_submonoid.mem_smul_pointwise_iff_exists AddSubmonoid.mem_smul_pointwise_iff_exists
+-/
 
+#print AddSubmonoid.smul_bot /-
 @[simp]
 theorem smul_bot (a : α) : a • (⊥ : AddSubmonoid A) = ⊥ :=
   map_bot _
 #align add_submonoid.smul_bot AddSubmonoid.smul_bot
+-/
 
+#print AddSubmonoid.smul_sup /-
 theorem smul_sup (a : α) (S T : AddSubmonoid A) : a • (S ⊔ T) = a • S ⊔ a • T :=
   map_sup _ _ _
 #align add_submonoid.smul_sup AddSubmonoid.smul_sup
+-/
 
+#print AddSubmonoid.smul_closure /-
 @[simp]
 theorem smul_closure (a : α) (s : Set A) : a • closure s = closure (a • s) :=
   AddMonoidHom.map_mclosure _ _
 #align add_submonoid.smul_closure AddSubmonoid.smul_closure
+-/
 
+#print AddSubmonoid.pointwise_isCentralScalar /-
 instance pointwise_isCentralScalar [DistribMulAction αᵐᵒᵖ A] [IsCentralScalar α A] :
     IsCentralScalar α (AddSubmonoid A) :=
   ⟨fun a S =>
     (congr_arg fun f : AddMonoid.End A => S.map f) <| AddMonoidHom.ext <| op_smul_eq_smul _⟩
 #align add_submonoid.pointwise_central_scalar AddSubmonoid.pointwise_isCentralScalar
+-/
 
 end Monoid
 
@@ -439,33 +525,45 @@ variable [Group α] [DistribMulAction α A]
 
 open scoped Pointwise
 
+#print AddSubmonoid.smul_mem_pointwise_smul_iff /-
 @[simp]
 theorem smul_mem_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff
 #align add_submonoid.smul_mem_pointwise_smul_iff AddSubmonoid.smul_mem_pointwise_smul_iff
+-/
 
+#print AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem /-
 theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : AddSubmonoid A} {x : A} :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem
 #align add_submonoid.mem_pointwise_smul_iff_inv_smul_mem AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem
+-/
 
+#print AddSubmonoid.mem_inv_pointwise_smul_iff /-
 theorem mem_inv_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff
 #align add_submonoid.mem_inv_pointwise_smul_iff AddSubmonoid.mem_inv_pointwise_smul_iff
+-/
 
+#print AddSubmonoid.pointwise_smul_le_pointwise_smul_iff /-
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} :
     a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff
 #align add_submonoid.pointwise_smul_le_pointwise_smul_iff AddSubmonoid.pointwise_smul_le_pointwise_smul_iff
+-/
 
+#print AddSubmonoid.pointwise_smul_le_iff /-
 theorem pointwise_smul_le_iff {a : α} {S T : AddSubmonoid A} : a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff
 #align add_submonoid.pointwise_smul_le_iff AddSubmonoid.pointwise_smul_le_iff
+-/
 
+#print AddSubmonoid.le_pointwise_smul_iff /-
 theorem le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} : S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff
 #align add_submonoid.le_pointwise_smul_iff AddSubmonoid.le_pointwise_smul_iff
+-/
 
 end Group
 
@@ -475,37 +573,49 @@ variable [GroupWithZero α] [DistribMulAction α A]
 
 open scoped Pointwise
 
+#print AddSubmonoid.smul_mem_pointwise_smul_iff₀ /-
 @[simp]
 theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
     a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff₀ ha (S : Set A) x
 #align add_submonoid.smul_mem_pointwise_smul_iff₀ AddSubmonoid.smul_mem_pointwise_smul_iff₀
+-/
 
+#print AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem₀ /-
 theorem mem_pointwise_smul_iff_inv_smul_mem₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem₀ ha (S : Set A) x
 #align add_submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem₀
+-/
 
+#print AddSubmonoid.mem_inv_pointwise_smul_iff₀ /-
 theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
     x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff₀ ha (S : Set A) x
 #align add_submonoid.mem_inv_pointwise_smul_iff₀ AddSubmonoid.mem_inv_pointwise_smul_iff₀
+-/
 
+#print AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀ /-
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
     a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff₀ ha
 #align add_submonoid.pointwise_smul_le_pointwise_smul_iff₀ AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀
+-/
 
+#print AddSubmonoid.pointwise_smul_le_iff₀ /-
 theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
     a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff₀ ha
 #align add_submonoid.pointwise_smul_le_iff₀ AddSubmonoid.pointwise_smul_le_iff₀
+-/
 
+#print AddSubmonoid.le_pointwise_smul_iff₀ /-
 theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
     S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff₀ ha
 #align add_submonoid.le_pointwise_smul_iff₀ AddSubmonoid.le_pointwise_smul_iff₀
+-/
 
 end GroupWithZero
 
@@ -534,14 +644,18 @@ theorem one_eq_mrange : (1 : AddSubmonoid R) = (Nat.castAddMonoidHom R).mrange :
 #align add_submonoid.one_eq_mrange AddSubmonoid.one_eq_mrange
 -/
 
+#print AddSubmonoid.natCast_mem_one /-
 theorem natCast_mem_one (n : ℕ) : (n : R) ∈ (1 : AddSubmonoid R) :=
   ⟨_, rfl⟩
 #align add_submonoid.nat_cast_mem_one AddSubmonoid.natCast_mem_one
+-/
 
+#print AddSubmonoid.mem_one /-
 @[simp]
 theorem mem_one {x : R} : x ∈ (1 : AddSubmonoid R) ↔ ∃ n : ℕ, ↑n = x :=
   Iff.rfl
 #align add_submonoid.mem_one AddSubmonoid.mem_one
+-/
 
 #print AddSubmonoid.one_eq_closure /-
 theorem one_eq_closure : (1 : AddSubmonoid R) = closure {1} :=
@@ -569,15 +683,20 @@ smallest R-submodule of `R` containing the elements `s * t` for `s ∈ S` and `t
 instance : Mul (AddSubmonoid R) :=
   ⟨fun M N => ⨆ s : M, N.map <| AddMonoidHom.mul s.1⟩
 
+#print AddSubmonoid.mul_mem_mul /-
 theorem mul_mem_mul {M N : AddSubmonoid R} {m n : R} (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N :=
   (le_iSup _ ⟨m, hm⟩ : _ ≤ M * N) ⟨n, hn, rfl⟩
 #align add_submonoid.mul_mem_mul AddSubmonoid.mul_mem_mul
+-/
 
+#print AddSubmonoid.mul_le /-
 theorem mul_le {M N P : AddSubmonoid R} : M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P :=
   ⟨fun H m hm n hn => H <| mul_mem_mul hm hn, fun H =>
     iSup_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
 #align add_submonoid.mul_le AddSubmonoid.mul_le
+-/
 
+#print AddSubmonoid.mul_induction_on /-
 @[elab_as_elim]
 protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r : R} (hr : r ∈ M * N)
     (hm : ∀ m ∈ M, ∀ n ∈ N, C (m * n)) (ha : ∀ x y, C x → C y → C (x + y)) : C r :=
@@ -585,9 +704,11 @@ protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r :
         ⟨C, ha, by simpa only [MulZeroClass.zero_mul] using hm _ (zero_mem _) _ (zero_mem _)⟩).2
     hm hr
 #align add_submonoid.mul_induction_on AddSubmonoid.mul_induction_on
+-/
 
 open scoped Pointwise
 
+#print AddSubmonoid.closure_mul_closure /-
 -- this proof is copied directly from `submodule.span_mul_span`
 theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S * T) :=
   by
@@ -606,41 +727,56 @@ theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S *
   · rw [closure_le]; rintro _ ⟨a, b, ha, hb, rfl⟩
     exact mul_mem_mul (subset_closure ha) (subset_closure hb)
 #align add_submonoid.closure_mul_closure AddSubmonoid.closure_mul_closure
+-/
 
+#print AddSubmonoid.mul_eq_closure_mul_set /-
 theorem mul_eq_closure_mul_set (M N : AddSubmonoid R) : M * N = closure (M * N) := by
   rw [← closure_mul_closure, closure_eq, closure_eq]
 #align add_submonoid.mul_eq_closure_mul_set AddSubmonoid.mul_eq_closure_mul_set
+-/
 
+#print AddSubmonoid.mul_bot /-
 @[simp]
 theorem mul_bot (S : AddSubmonoid R) : S * ⊥ = ⊥ :=
   eq_bot_iff.2 <|
     mul_le.2 fun m hm n hn => by
       rw [AddSubmonoid.mem_bot] at hn ⊢ <;> rw [hn, MulZeroClass.mul_zero]
 #align add_submonoid.mul_bot AddSubmonoid.mul_bot
+-/
 
+#print AddSubmonoid.bot_mul /-
 @[simp]
 theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ :=
   eq_bot_iff.2 <|
     mul_le.2 fun m hm n hn => by
       rw [AddSubmonoid.mem_bot] at hm ⊢ <;> rw [hm, MulZeroClass.zero_mul]
 #align add_submonoid.bot_mul AddSubmonoid.bot_mul
+-/
 
+#print AddSubmonoid.mul_le_mul /-
 @[mono]
 theorem mul_le_mul {M N P Q : AddSubmonoid R} (hmp : M ≤ P) (hnq : N ≤ Q) : M * N ≤ P * Q :=
   mul_le.2 fun m hm n hn => mul_mem_mul (hmp hm) (hnq hn)
 #align add_submonoid.mul_le_mul AddSubmonoid.mul_le_mul
+-/
 
+#print AddSubmonoid.mul_le_mul_left /-
 theorem mul_le_mul_left {M N P : AddSubmonoid R} (h : M ≤ N) : M * P ≤ N * P :=
   mul_le_mul h (le_refl P)
 #align add_submonoid.mul_le_mul_left AddSubmonoid.mul_le_mul_left
+-/
 
+#print AddSubmonoid.mul_le_mul_right /-
 theorem mul_le_mul_right {M N P : AddSubmonoid R} (h : N ≤ P) : M * N ≤ M * P :=
   mul_le_mul (le_refl M) h
 #align add_submonoid.mul_le_mul_right AddSubmonoid.mul_le_mul_right
+-/
 
+#print AddSubmonoid.mul_subset_mul /-
 theorem mul_subset_mul {M N : AddSubmonoid R} : (↑M : Set R) * (↑N : Set R) ⊆ (↑(M * N) : Set R) :=
   by rintro _ ⟨i, j, hi, hj, rfl⟩; exact mul_mem_mul hi hj
 #align add_submonoid.mul_subset_mul AddSubmonoid.mul_subset_mul
+-/
 
 end NonUnitalNonAssocSemiring
 
@@ -648,6 +784,7 @@ section NonUnitalNonAssocRing
 
 variable [NonUnitalNonAssocRing R]
 
+#print AddSubmonoid.hasDistribNeg /-
 /-- `add_submonoid.has_pointwise_neg` distributes over multiplication.
 
 This is available as an instance in the `pointwise` locale. -/
@@ -671,6 +808,7 @@ protected def hasDistribNeg : HasDistribNeg (AddSubmonoid R) :=
       · exact mul_mem_mul hm hn
       · exact mul_mem_mul hm (neg_mem_neg.2 hn) }
 #align add_submonoid.has_distrib_neg AddSubmonoid.hasDistribNeg
+-/
 
 scoped[Pointwise] attribute [instance] AddSubmonoid.hasDistribNeg
 
@@ -718,18 +856,24 @@ instance : Monoid (AddSubmonoid R) :=
     one := 1
     mul := (· * ·) }
 
+#print AddSubmonoid.closure_pow /-
 theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)
   | 0 => by rw [pow_zero, pow_zero, one_eq_closure_one_set]
   | n + 1 => by rw [pow_succ, pow_succ, closure_pow, closure_mul_closure]
 #align add_submonoid.closure_pow AddSubmonoid.closure_pow
+-/
 
+#print AddSubmonoid.pow_eq_closure_pow_set /-
 theorem pow_eq_closure_pow_set (s : AddSubmonoid R) (n : ℕ) : s ^ n = closure ((s : Set R) ^ n) :=
   by rw [← closure_pow, closure_eq]
 #align add_submonoid.pow_eq_closure_pow_set AddSubmonoid.pow_eq_closure_pow_set
+-/
 
+#print AddSubmonoid.pow_subset_pow /-
 theorem pow_subset_pow {s : AddSubmonoid R} {n : ℕ} : (↑s : Set R) ^ n ⊆ ↑(s ^ n) :=
   (pow_eq_closure_pow_set s n).symm ▸ subset_closure
 #align add_submonoid.pow_subset_pow AddSubmonoid.pow_subset_pow
+-/
 
 end Semiring
 
@@ -739,6 +883,7 @@ namespace Set.IsPwo
 
 variable [OrderedCancelCommMonoid α] {s : Set α}
 
+#print Set.IsPwo.submonoid_closure /-
 @[to_additive]
 theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPwo) :
     IsPwo (Submonoid.closure s : Set α) :=
@@ -748,6 +893,7 @@ theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPwo)
   exact fun l1 hl1 l2 hl2 h12 => h12.prod_le_prod' fun x hx => hpos x <| hl2 x hx
 #align set.is_pwo.submonoid_closure Set.IsPwo.submonoid_closure
 #align set.is_pwo.add_submonoid_closure Set.IsPwo.addSubmonoid_closure
+-/
 
 end Set.IsPwo
 

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

@@ -595,9 +595,9 @@ theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S *
   · rw [mul_le]; intro a ha b hb
     apply closure_induction ha
     on_goal 1 =>
-      intros ; apply closure_induction hb
-      on_goal 1 => intros ; exact subset_closure ⟨_, _, ‹_›, ‹_›, rfl⟩
-    all_goals intros ;
+      intros; apply closure_induction hb
+      on_goal 1 => intros; exact subset_closure ⟨_, _, ‹_›, ‹_›, rfl⟩
+    all_goals intros;
       simp only [MulZeroClass.mul_zero, MulZeroClass.zero_mul, zero_mem, left_distrib,
           right_distrib, mul_smul_comm, smul_mul_assoc] <;>
         solve_by_elim (config :=
@@ -614,13 +614,15 @@ theorem mul_eq_closure_mul_set (M N : AddSubmonoid R) : M * N = closure (M * N)
 @[simp]
 theorem mul_bot (S : AddSubmonoid R) : S * ⊥ = ⊥ :=
   eq_bot_iff.2 <|
-    mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hn⊢ <;> rw [hn, MulZeroClass.mul_zero]
+    mul_le.2 fun m hm n hn => by
+      rw [AddSubmonoid.mem_bot] at hn ⊢ <;> rw [hn, MulZeroClass.mul_zero]
 #align add_submonoid.mul_bot AddSubmonoid.mul_bot
 
 @[simp]
 theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ :=
   eq_bot_iff.2 <|
-    mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hm⊢ <;> rw [hm, MulZeroClass.zero_mul]
+    mul_le.2 fun m hm n hn => by
+      rw [AddSubmonoid.mem_bot] at hm ⊢ <;> rw [hm, MulZeroClass.zero_mul]
 #align add_submonoid.bot_mul AddSubmonoid.bot_mul
 
 @[mono]

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

@@ -61,7 +61,7 @@ variable [Monoid M] [AddMonoid A]
 
 namespace Submonoid
 
-open Pointwise
+open scoped Pointwise
 
 variable {s t u : Set M}
 
@@ -122,7 +122,7 @@ theorem pow_smul_mem_closure_smul {N : Type _} [CommMonoid N] [MulAction M N] [I
 
 variable [Group G]
 
-open Pointwise
+open scoped Pointwise
 
 #print Submonoid.inv /-
 /-- The submonoid with every element inverted. -/
@@ -139,7 +139,7 @@ protected def inv : Inv (Submonoid G)
 
 scoped[Pointwise] attribute [instance] Submonoid.inv
 
-open Pointwise
+open scoped Pointwise
 
 @[simp, to_additive]
 theorem coe_inv (S : Submonoid G) : ↑S⁻¹ = (S : Set G)⁻¹ :=
@@ -251,7 +251,7 @@ protected def pointwiseMulAction : MulAction α (Submonoid M)
 
 scoped[Pointwise] attribute [instance] Submonoid.pointwiseMulAction
 
-open Pointwise
+open scoped Pointwise
 
 @[simp]
 theorem coe_pointwise_smul (a : α) (S : Submonoid M) : ↑(a • S) = a • (S : Set M) :=
@@ -293,7 +293,7 @@ section Group
 
 variable [Group α] [MulDistribMulAction α M]
 
-open Pointwise
+open scoped Pointwise
 
 @[simp]
 theorem smul_mem_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : a • x ∈ a • S ↔ x ∈ S :=
@@ -328,7 +328,7 @@ section GroupWithZero
 
 variable [GroupWithZero α] [MulDistribMulAction α M]
 
-open Pointwise
+open scoped Pointwise
 
 @[simp]
 theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
@@ -362,7 +362,7 @@ theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : S
 
 end GroupWithZero
 
-open Pointwise
+open scoped Pointwise
 
 @[to_additive]
 theorem mem_closure_inv {G : Type _} [Group G] (S : Set G) (x : G) :
@@ -395,7 +395,7 @@ protected def pointwiseMulAction : MulAction α (AddSubmonoid A)
 
 scoped[Pointwise] attribute [instance] AddSubmonoid.pointwiseMulAction
 
-open Pointwise
+open scoped Pointwise
 
 @[simp]
 theorem coe_pointwise_smul (a : α) (S : AddSubmonoid A) : ↑(a • S) = a • (S : Set A) :=
@@ -437,7 +437,7 @@ section Group
 
 variable [Group α] [DistribMulAction α A]
 
-open Pointwise
+open scoped Pointwise
 
 @[simp]
 theorem smul_mem_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : a • x ∈ a • S ↔ x ∈ S :=
@@ -473,7 +473,7 @@ section GroupWithZero
 
 variable [GroupWithZero α] [DistribMulAction α A]
 
-open Pointwise
+open scoped Pointwise
 
 @[simp]
 theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
@@ -519,7 +519,7 @@ usually more useful. -/
 
 namespace AddSubmonoid
 
-open Pointwise
+open scoped Pointwise
 
 section AddMonoidWithOne
 
@@ -586,7 +586,7 @@ protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r :
     hm hr
 #align add_submonoid.mul_induction_on AddSubmonoid.mul_induction_on
 
-open Pointwise
+open scoped Pointwise
 
 -- this proof is copied directly from `submodule.span_mul_span`
 theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S * T) :=

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

@@ -65,36 +65,18 @@ open Pointwise
 
 variable {s t u : Set M}
 
-/- warning: submonoid.mul_subset -> Submonoid.mul_subset is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {t : Set.{u1} M} {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) s ((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))))) S)) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) t ((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))))) S)) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) s t) ((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))))) S))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {t : Set.{u1} M} {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) s (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)) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) t (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)) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) s t) (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))
-Case conversion may be inaccurate. Consider using '#align submonoid.mul_subset Submonoid.mul_subsetₓ'. -/
 @[to_additive]
 theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S := by
   rintro _ ⟨p, q, hp, hq, rfl⟩; exact Submonoid.mul_mem _ (hs hp) (ht hq)
 #align submonoid.mul_subset Submonoid.mul_subset
 #align add_submonoid.add_subset AddSubmonoid.add_subset
 
-/- warning: submonoid.mul_subset_closure -> Submonoid.mul_subset_closure is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {t : Set.{u1} M} {u : Set.{u1} M}, (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) s u) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) t u) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.hasSubset.{u1} M) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) s t) ((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) u)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {t : Set.{u1} M} {u : Set.{u1} M}, (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) s u) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) t u) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) s t) (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) u)))
-Case conversion may be inaccurate. Consider using '#align submonoid.mul_subset_closure Submonoid.mul_subset_closureₓ'. -/
 @[to_additive]
 theorem mul_subset_closure (hs : s ⊆ u) (ht : t ⊆ u) : s * t ⊆ Submonoid.closure u :=
   mul_subset (Subset.trans hs Submonoid.subset_closure) (Subset.trans ht Submonoid.subset_closure)
 #align submonoid.mul_subset_closure Submonoid.mul_subset_closure
 #align add_submonoid.add_subset_closure AddSubmonoid.add_subset_closure
 
-/- warning: submonoid.coe_mul_self_eq -> Submonoid.coe_mul_self_eq 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)), Eq.{succ u1} (Set.{u1} M) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (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))))) s) ((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))))) s)) ((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))))) 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)), Eq.{succ u1} (Set.{u1} M) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (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) (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)) (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)
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_mul_self_eq Submonoid.coe_mul_self_eqₓ'. -/
 @[to_additive]
 theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s :=
   by
@@ -105,12 +87,6 @@ theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s :=
 #align submonoid.coe_mul_self_eq Submonoid.coe_mul_self_eq
 #align add_submonoid.coe_add_self_eq AddSubmonoid.coe_add_self_eq
 
-/- warning: submonoid.closure_mul_le -> Submonoid.closure_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
-Case conversion may be inaccurate. Consider using '#align submonoid.closure_mul_le Submonoid.closure_mul_leₓ'. -/
 @[to_additive]
 theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T :=
   sInf_le fun x ⟨s, t, hs, ht, hx⟩ =>
@@ -120,12 +96,6 @@ theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure
 #align submonoid.closure_mul_le Submonoid.closure_mul_le
 #align add_submonoid.closure_add_le AddSubmonoid.closure_add_le
 
-/- warning: submonoid.sup_eq_closure -> Submonoid.sup_eq_closure is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (H : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (K : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) H K) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (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))))) H) ((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))))) K)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (H : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (K : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) H K) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) H) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) K)))
-Case conversion may be inaccurate. Consider using '#align submonoid.sup_eq_closure Submonoid.sup_eq_closureₓ'. -/
 @[to_additive]
 theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure (H * K) :=
   le_antisymm
@@ -135,12 +105,6 @@ theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure (H * K) :=
 #align submonoid.sup_eq_closure Submonoid.sup_eq_closure
 #align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure
 
-/- warning: submonoid.pow_smul_mem_closure_smul -> Submonoid.pow_smul_mem_closure_smul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u2}} [_inst_3 : CommMonoid.{u2} N] [_inst_4 : MulAction.{u1, u2} M N _inst_1] [_inst_5 : IsScalarTower.{u1, u2, u2} M N N (MulAction.toHasSmul.{u1, u2} M N _inst_1 _inst_4) (Mul.toSMul.{u2} N (MulOneClass.toHasMul.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)))) (MulAction.toHasSmul.{u1, u2} M N _inst_1 _inst_4)] (r : M) (s : Set.{u2} N) {x : N}, (Membership.Mem.{u2, u2} N (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) N (Submonoid.setLike.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)))) x (Submonoid.closure.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)) s)) -> (Exists.{1} Nat (fun (n : Nat) => Membership.Mem.{u2, u2} N (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) N (Submonoid.setLike.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)))) (SMul.smul.{u1, u2} M N (MulAction.toHasSmul.{u1, u2} M N _inst_1 _inst_4) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) r n) x) (Submonoid.closure.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)) (SMul.smul.{u1, u2} M (Set.{u2} N) (Set.smulSet.{u1, u2} M N (MulAction.toHasSmul.{u1, u2} M N _inst_1 _inst_4)) r s))))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {N : Type.{u2}} [_inst_3 : CommMonoid.{u2} N] [_inst_4 : MulAction.{u1, u2} M N _inst_1] [_inst_5 : IsScalarTower.{u1, u2, u2} M N N (MulAction.toSMul.{u1, u2} M N _inst_1 _inst_4) (MulAction.toSMul.{u2, u2} N N (CommMonoid.toMonoid.{u2} N _inst_3) (Monoid.toMulAction.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) (MulAction.toSMul.{u1, u2} M N _inst_1 _inst_4)] (r : M) (s : Set.{u2} N) {x : N}, (Membership.mem.{u2, u2} N (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) N (Submonoid.instSetLikeSubmonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)))) x (Submonoid.closure.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)) s)) -> (Exists.{1} Nat (fun (n : Nat) => Membership.mem.{u2, u2} N (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) (SetLike.instMembership.{u2, u2} (Submonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3))) N (Submonoid.instSetLikeSubmonoid.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)))) (HSMul.hSMul.{u1, u2, u2} M N N (instHSMul.{u1, u2} M N (MulAction.toSMul.{u1, u2} M N _inst_1 _inst_4)) (HPow.hPow.{u1, 0, u1} M Nat M (instHPow.{u1, 0} M Nat (Monoid.Pow.{u1} M _inst_1)) r n) x) (Submonoid.closure.{u2} N (Monoid.toMulOneClass.{u2} N (CommMonoid.toMonoid.{u2} N _inst_3)) (HSMul.hSMul.{u1, u2, u2} M (Set.{u2} N) (Set.{u2} N) (instHSMul.{u1, u2} M (Set.{u2} N) (Set.smulSet.{u1, u2} M N (MulAction.toSMul.{u1, u2} M N _inst_1 _inst_4))) r s))))
-Case conversion may be inaccurate. Consider using '#align submonoid.pow_smul_mem_closure_smul Submonoid.pow_smul_mem_closure_smulₓ'. -/
 @[to_additive]
 theorem pow_smul_mem_closure_smul {N : Type _} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]
     (r : M) (s : Set N) {x : N} (hx : x ∈ closure s) : ∃ n : ℕ, r ^ n • x ∈ closure (r • s) :=
@@ -177,24 +141,12 @@ scoped[Pointwise] attribute [instance] Submonoid.inv
 
 open Pointwise
 
-/- warning: submonoid.coe_inv -> Submonoid.coe_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Set.{u1} G) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S)) (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Set.{u1} G) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Set.{u1} G) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Set.{u1} G) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) S))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Set.{u1} G) (SetLike.coe.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.instSetLikeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S)) (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_3))))) (SetLike.coe.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.instSetLikeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) S))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_inv Submonoid.coe_invₓ'. -/
 @[simp, to_additive]
 theorem coe_inv (S : Submonoid G) : ↑S⁻¹ = (S : Set G)⁻¹ :=
   rfl
 #align submonoid.coe_inv Submonoid.coe_inv
 #align add_submonoid.coe_neg AddSubmonoid.coe_neg
 
-/- warning: submonoid.mem_inv -> Submonoid.mem_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {g : G} {S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))}, Iff (Membership.Mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) g (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S)) (Membership.Mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)) g) S)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {g : G} {S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))}, Iff (Membership.mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.instSetLikeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) g (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S)) (Membership.mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.instSetLikeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_3)))) g) S)
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_inv Submonoid.mem_invₓ'. -/
 @[simp, to_additive]
 theorem mem_inv {g : G} {S : Submonoid G} : g ∈ S⁻¹ ↔ g⁻¹ ∈ S :=
   Iff.rfl
@@ -205,36 +157,18 @@ theorem mem_inv {g : G} {S : Submonoid G} : g ∈ S⁻¹ ↔ g⁻¹ ∈ S :=
 instance : InvolutiveInv (Submonoid G) :=
   SetLike.coe_injective.InvolutiveInv _ fun _ => rfl
 
-/- warning: submonoid.inv_le_inv -> Submonoid.inv_le_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T)) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) S T)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T)) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_le_inv Submonoid.inv_le_invₓ'. -/
 @[simp, to_additive]
 theorem inv_le_inv (S T : Submonoid G) : S⁻¹ ≤ T⁻¹ ↔ S ≤ T :=
   SetLike.coe_subset_coe.symm.trans Set.inv_subset_inv
 #align submonoid.inv_le_inv Submonoid.inv_le_inv
 #align add_submonoid.neg_le_neg AddSubmonoid.neg_le_neg
 
-/- warning: submonoid.inv_le -> Submonoid.inv_le is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) T) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) S (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) T) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_le Submonoid.inv_leₓ'. -/
 @[to_additive]
 theorem inv_le (S T : Submonoid G) : S⁻¹ ≤ T ↔ S ≤ T⁻¹ :=
   SetLike.coe_subset_coe.symm.trans Set.inv_subset
 #align submonoid.inv_le Submonoid.inv_le
 #align add_submonoid.neg_le AddSubmonoid.neg_le
 
-/- warning: submonoid.inv_order_iso -> Submonoid.invOrderIso is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], OrderIso.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], OrderIso.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_order_iso Submonoid.invOrderIsoₓ'. -/
 /-- `submonoid.has_inv` as an order isomorphism. -/
 @[to_additive " `add_submonoid.has_neg` as an order isomorphism ", simps]
 def invOrderIso : Submonoid G ≃o Submonoid G
@@ -244,12 +178,6 @@ def invOrderIso : Submonoid G ≃o Submonoid G
 #align submonoid.inv_order_iso Submonoid.invOrderIso
 #align add_submonoid.neg_order_iso AddSubmonoid.negOrderIso
 
-/- warning: submonoid.closure_inv -> Submonoid.closure_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) s)) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (s : Set.{u1} G), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_3))))) s)) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) s))
-Case conversion may be inaccurate. Consider using '#align submonoid.closure_inv Submonoid.closure_invₓ'. -/
 @[to_additive]
 theorem closure_inv (s : Set G) : closure s⁻¹ = (closure s)⁻¹ :=
   by
@@ -261,48 +189,24 @@ theorem closure_inv (s : Set G) : closure s⁻¹ = (closure s)⁻¹ :=
 #align submonoid.closure_inv Submonoid.closure_inv
 #align add_submonoid.closure_neg AddSubmonoid.closure_neg
 
-/- warning: submonoid.inv_inf -> Submonoid.inv_inf is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasInf.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) S T)) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasInf.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instInfSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) S T)) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instInfSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_inf Submonoid.inv_infₓ'. -/
 @[simp, to_additive]
 theorem inv_inf (S T : Submonoid G) : (S ⊓ T)⁻¹ = S⁻¹ ⊓ T⁻¹ :=
   SetLike.coe_injective Set.inter_inv
 #align submonoid.inv_inf Submonoid.inv_inf
 #align add_submonoid.neg_inf AddSubmonoid.neg_inf
 
-/- warning: submonoid.inv_sup -> Submonoid.inv_sup is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_sup Submonoid.inv_supₓ'. -/
 @[simp, to_additive]
 theorem inv_sup (S T : Submonoid G) : (S ⊔ T)⁻¹ = S⁻¹ ⊔ T⁻¹ :=
   (invOrderIso : Submonoid G ≃o Submonoid G).map_sup S T
 #align submonoid.inv_sup Submonoid.inv_sup
 #align add_submonoid.neg_sup AddSubmonoid.neg_sup
 
-/- warning: submonoid.inv_bot -> Submonoid.inv_bot is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Bot.bot.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasBot.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) (Bot.bot.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasBot.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Bot.bot.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instBotSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) (Bot.bot.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instBotSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_bot Submonoid.inv_botₓ'. -/
 @[simp, to_additive]
 theorem inv_bot : (⊥ : Submonoid G)⁻¹ = ⊥ :=
   SetLike.coe_injective <| (Set.inv_singleton 1).trans <| congr_arg _ inv_one
 #align submonoid.inv_bot Submonoid.inv_bot
 #align add_submonoid.neg_bot AddSubmonoid.neg_bot
 
-/- warning: submonoid.inv_top -> Submonoid.inv_top is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Top.top.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasTop.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) (Top.top.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasTop.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Top.top.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instTopSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) (Top.top.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instTopSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_top Submonoid.inv_topₓ'. -/
 @[simp, to_additive]
 theorem inv_top : (⊤ : Submonoid G)⁻¹ = ⊤ :=
   SetLike.coe_injective <| Set.inv_univ
@@ -317,12 +221,6 @@ theorem inv_iInf {ι : Sort _} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = 
 #align add_submonoid.neg_infi AddSubmonoid.neg_iInf
 -/
 
-/- warning: submonoid.inv_supr -> Submonoid.inv_iSup is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => S i))) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (S i)))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toSupSet.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => S i))) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toSupSet.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (S i)))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_supr Submonoid.inv_iSupₓ'. -/
 @[simp, to_additive]
 theorem inv_iSup {ι : Sort _} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
   (invOrderIso : Submonoid G ≃o Submonoid G).map_iSup _
@@ -355,55 +253,25 @@ scoped[Pointwise] attribute [instance] Submonoid.pointwiseMulAction
 
 open Pointwise
 
-/- warning: submonoid.coe_pointwise_smul -> Submonoid.coe_pointwise_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Set.{u2} M) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Set.{u2} M) (HasLiftT.mk.{succ u2, succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Set.{u2} M) (CoeTCₓ.coe.{succ u2, succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Set.{u2} M) (SetLike.Set.hasCoeT.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a S)) (SMul.smul.{u1, u2} α (Set.{u2} M) (Set.smulSet.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4))) a ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Set.{u2} M) (HasLiftT.mk.{succ u2, succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Set.{u2} M) (CoeTCₓ.coe.{succ u2, succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Set.{u2} M) (SetLike.Set.hasCoeT.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S))
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Set.{u2} M) (SetLike.coe.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a S)) (HSMul.hSMul.{u1, u2, u2} α (Set.{u2} M) (Set.{u2} M) (instHSMul.{u1, u2} α (Set.{u2} M) (Set.smulSet.{u1, u2} α M (MulAction.toSMul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4)))) a (SetLike.coe.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) S))
-Case conversion may be inaccurate. Consider using '#align submonoid.coe_pointwise_smul Submonoid.coe_pointwise_smulₓ'. -/
 @[simp]
 theorem coe_pointwise_smul (a : α) (S : Submonoid M) : ↑(a • S) = a • (S : Set M) :=
   rfl
 #align submonoid.coe_pointwise_smul Submonoid.coe_pointwise_smul
 
-/- warning: submonoid.smul_mem_pointwise_smul -> Submonoid.smul_mem_pointwise_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (m : M) (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) m S) -> (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4)) a m) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a S))
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (m : M) (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), (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))) m 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))) (HSMul.hSMul.{u1, u2, u2} α M M (instHSMul.{u1, u2} α M (MulAction.toSMul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4))) a m) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a S))
-Case conversion may be inaccurate. Consider using '#align submonoid.smul_mem_pointwise_smul Submonoid.smul_mem_pointwise_smulₓ'. -/
 theorem smul_mem_pointwise_smul (m : M) (a : α) (S : Submonoid M) : m ∈ S → a • m ∈ a • S :=
   (Set.smul_mem_smul_set : _ → _ ∈ a • (S : Set M))
 #align submonoid.smul_mem_pointwise_smul Submonoid.smul_mem_pointwise_smul
 
-/- warning: submonoid.mem_smul_pointwise_iff_exists -> Submonoid.mem_smul_pointwise_iff_exists is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (m : M) (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Iff (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) m (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a S)) (Exists.{succ u2} M (fun (s : M) => And (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) s S) (Eq.{succ u2} M (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4)) a s) m)))
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (m : M) (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Iff (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))) m (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a S)) (Exists.{succ u2} M (fun (s : M) => And (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))) s S) (Eq.{succ u2} M (HSMul.hSMul.{u1, u2, u2} α M M (instHSMul.{u1, u2} α M (MulAction.toSMul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4))) a s) m)))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_smul_pointwise_iff_exists Submonoid.mem_smul_pointwise_iff_existsₓ'. -/
 theorem mem_smul_pointwise_iff_exists (m : M) (a : α) (S : Submonoid M) :
     m ∈ a • S ↔ ∃ s : M, s ∈ S ∧ a • s = m :=
   (Set.mem_smul_set : m ∈ a • (S : Set M) ↔ _)
 #align submonoid.mem_smul_pointwise_iff_exists Submonoid.mem_smul_pointwise_iff_exists
 
-/- warning: submonoid.smul_bot -> Submonoid.smul_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a (Bot.bot.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.hasBot.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (Bot.bot.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.hasBot.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a (Bot.bot.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instBotSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))) (Bot.bot.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instBotSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))
-Case conversion may be inaccurate. Consider using '#align submonoid.smul_bot Submonoid.smul_botₓ'. -/
 @[simp]
 theorem smul_bot (a : α) : a • (⊥ : Submonoid M) = ⊥ :=
   map_bot _
 #align submonoid.smul_bot Submonoid.smul_bot
 
-/- warning: submonoid.smul_sup -> Submonoid.smul_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.completeLattice.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)) (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.completeLattice.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a T))
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)) (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a T))
-Case conversion may be inaccurate. Consider using '#align submonoid.smul_sup Submonoid.smul_supₓ'. -/
 theorem smul_sup (a : α) (S T : Submonoid M) : a • (S ⊔ T) = a • S ⊔ a • T :=
   map_sup _ _ _
 #align submonoid.smul_sup Submonoid.smul_sup
@@ -414,12 +282,6 @@ theorem smul_closure (a : α) (s : Set M) : a • closure s = closure (a • s)
 #align submonoid.smul_closure Submonoid.smul_closure
 -/
 
-/- warning: submonoid.pointwise_central_scalar -> Submonoid.pointwise_isCentralScalar is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] [_inst_5 : MulDistribMulAction.{u1, u2} (MulOpposite.{u1} α) M (MulOpposite.monoid.{u1} α _inst_3) _inst_1] [_inst_6 : IsCentralScalar.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4)) (MulAction.toHasSmul.{u1, u2} (MulOpposite.{u1} α) M (MulOpposite.monoid.{u1} α _inst_3) (MulDistribMulAction.toMulAction.{u1, u2} (MulOpposite.{u1} α) M (MulOpposite.monoid.{u1} α _inst_3) _inst_1 _inst_5))], IsCentralScalar.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) (MulAction.toHasSmul.{u1, u2} (MulOpposite.{u1} α) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOpposite.monoid.{u1} α _inst_3) (Submonoid.pointwiseMulAction.{u1, u2} (MulOpposite.{u1} α) M _inst_1 (MulOpposite.monoid.{u1} α _inst_3) _inst_5))
-but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : Monoid.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M _inst_3 _inst_1] [_inst_5 : MulDistribMulAction.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.monoid.{u2} α _inst_3) _inst_1] [_inst_6 : IsCentralScalar.{u2, u1} α M (MulAction.toSMul.{u2, u1} α M _inst_3 (MulDistribMulAction.toMulAction.{u2, u1} α M _inst_3 _inst_1 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.monoid.{u2} α _inst_3) (MulDistribMulAction.toMulAction.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.monoid.{u2} α _inst_3) _inst_1 _inst_5))], IsCentralScalar.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 _inst_3 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOpposite.monoid.{u2} α _inst_3) (Submonoid.pointwiseMulAction.{u2, u1} (MulOpposite.{u2} α) M _inst_1 (MulOpposite.monoid.{u2} α _inst_3) _inst_5))
-Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_central_scalar Submonoid.pointwise_isCentralScalarₓ'. -/
 instance pointwise_isCentralScalar [MulDistribMulAction αᵐᵒᵖ M] [IsCentralScalar α M] :
     IsCentralScalar α (Submonoid M) :=
   ⟨fun a S => (congr_arg fun f : Monoid.End M => S.map f) <| MonoidHom.ext <| op_smul_eq_smul _⟩
@@ -433,65 +295,29 @@ variable [Group α] [MulDistribMulAction α M]
 
 open Pointwise
 
-/- warning: submonoid.smul_mem_pointwise_smul_iff -> Submonoid.smul_mem_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {x : M}, Iff (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1 _inst_4)) a x) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x S)
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {x : M}, Iff (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))) (HSMul.hSMul.{u1, u2, u2} α M M (instHSMul.{u1, u2} α M (MulAction.toSMul.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1 _inst_4))) a x) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a 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))) x S)
-Case conversion may be inaccurate. Consider using '#align submonoid.smul_mem_pointwise_smul_iff Submonoid.smul_mem_pointwise_smul_iffₓ'. -/
 @[simp]
 theorem smul_mem_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff
 #align submonoid.smul_mem_pointwise_smul_iff Submonoid.smul_mem_pointwise_smul_iff
 
-/- warning: submonoid.mem_pointwise_smul_iff_inv_smul_mem -> Submonoid.mem_pointwise_smul_iff_inv_smul_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {x : M}, Iff (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1 _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) x) S)
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {x : M}, Iff (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))) x (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a 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))) (HSMul.hSMul.{u1, u2, u2} α M M (instHSMul.{u1, u2} α M (MulAction.toSMul.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1 _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) x) S)
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_pointwise_smul_iff_inv_smul_mem Submonoid.mem_pointwise_smul_iff_inv_smul_memₓ'. -/
 theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : Submonoid M} {x : M} :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem
 #align submonoid.mem_pointwise_smul_iff_inv_smul_mem Submonoid.mem_pointwise_smul_iff_inv_smul_mem
 
-/- warning: submonoid.mem_inv_pointwise_smul_iff -> Submonoid.mem_inv_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {x : M}, Iff (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S)) (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1 _inst_4)) a x) S)
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {x : M}, Iff (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))) x (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) 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))) (HSMul.hSMul.{u1, u2, u2} α M M (instHSMul.{u1, u2} α M (MulAction.toSMul.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1 _inst_4))) a x) S)
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_inv_pointwise_smul_iff Submonoid.mem_inv_pointwise_smul_iffₓ'. -/
 theorem mem_inv_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff
 #align submonoid.mem_inv_pointwise_smul_iff Submonoid.mem_inv_pointwise_smul_iff
 
-/- warning: submonoid.pointwise_smul_le_pointwise_smul_iff -> Submonoid.pointwise_smul_le_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S T)
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)
-Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_le_pointwise_smul_iff Submonoid.pointwise_smul_le_pointwise_smul_iffₓ'. -/
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : Submonoid M} : a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff
 #align submonoid.pointwise_smul_le_pointwise_smul_iff Submonoid.pointwise_smul_le_pointwise_smul_iff
 
-/- warning: submonoid.pointwise_smul_subset_iff -> Submonoid.pointwise_smul_subset_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) T))
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) T))
-Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_subset_iff Submonoid.pointwise_smul_subset_iffₓ'. -/
 theorem pointwise_smul_subset_iff {a : α} {S T : Submonoid M} : a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff
 #align submonoid.pointwise_smul_subset_iff Submonoid.pointwise_smul_subset_iff
 
-/- warning: submonoid.subset_pointwise_smul_iff -> Submonoid.subset_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S) T)
-but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) S) T)
-Case conversion may be inaccurate. Consider using '#align submonoid.subset_pointwise_smul_iff Submonoid.subset_pointwise_smul_iffₓ'. -/
 theorem subset_pointwise_smul_iff {a : α} {S T : Submonoid M} : S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff
 #align submonoid.subset_pointwise_smul_iff Submonoid.subset_pointwise_smul_iff
@@ -504,68 +330,32 @@ variable [GroupWithZero α] [MulDistribMulAction α M]
 
 open Pointwise
 
-/- warning: submonoid.smul_mem_pointwise_smul_iff₀ -> Submonoid.smul_mem_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (x : M), Iff (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1 _inst_4)) a x) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x S))
-but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x : 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))) (HSMul.hSMul.{u2, u1, u1} α M M (instHSMul.{u2, u1} α M (MulAction.toSMul.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (MulDistribMulAction.toMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1 _inst_4))) a x) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a 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))) x S))
-Case conversion may be inaccurate. Consider using '#align submonoid.smul_mem_pointwise_smul_iff₀ Submonoid.smul_mem_pointwise_smul_iff₀ₓ'. -/
 @[simp]
 theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
     a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff₀ ha (S : Set M) x
 #align submonoid.smul_mem_pointwise_smul_iff₀ Submonoid.smul_mem_pointwise_smul_iff₀
 
-/- warning: submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ -> Submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (x : M), Iff (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1 _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) x) S))
-but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x : 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 (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a 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))) (HSMul.hSMul.{u2, u1, u1} α M M (instHSMul.{u2, u1} α M (MulAction.toSMul.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (MulDistribMulAction.toMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1 _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) x) S))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ Submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ₓ'. -/
 theorem mem_pointwise_smul_iff_inv_smul_mem₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem₀ ha (S : Set M) x
 #align submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ Submonoid.mem_pointwise_smul_iff_inv_smul_mem₀
 
-/- warning: submonoid.mem_inv_pointwise_smul_iff₀ -> Submonoid.mem_inv_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (x : M), Iff (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) x (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S)) (Membership.Mem.{u2, u2} M (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.hasMem.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))) (SMul.smul.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (MulDistribMulAction.toMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1 _inst_4)) a x) S))
-but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall (S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (x : 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 (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) 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))) (HSMul.hSMul.{u2, u1, u1} α M M (instHSMul.{u2, u1} α M (MulAction.toSMul.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (MulDistribMulAction.toMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1 _inst_4))) a x) S))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_inv_pointwise_smul_iff₀ Submonoid.mem_inv_pointwise_smul_iff₀ₓ'. -/
 theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M) (x : M) :
     x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff₀ ha (S : Set M) x
 #align submonoid.mem_inv_pointwise_smul_iff₀ Submonoid.mem_inv_pointwise_smul_iff₀
 
-/- warning: submonoid.pointwise_smul_le_pointwise_smul_iff₀ -> Submonoid.pointwise_smul_le_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S T))
-but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} {T : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, Iff (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)))))) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (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)))))) S T))
-Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_le_pointwise_smul_iff₀ Submonoid.pointwise_smul_le_pointwise_smul_iff₀ₓ'. -/
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} :
     a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff₀ ha
 #align submonoid.pointwise_smul_le_pointwise_smul_iff₀ Submonoid.pointwise_smul_le_pointwise_smul_iff₀
 
-/- warning: submonoid.pointwise_smul_le_iff₀ -> Submonoid.pointwise_smul_le_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) T)))
-but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} {T : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, Iff (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)))))) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) T) (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)))))) S (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) T)))
-Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_le_iff₀ Submonoid.pointwise_smul_le_iff₀ₓ'. -/
 theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff₀ ha
 #align submonoid.pointwise_smul_le_iff₀ Submonoid.pointwise_smul_le_iff₀
 
-/- warning: submonoid.le_pointwise_smul_iff₀ -> Submonoid.le_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S) T))
-but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} {T : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, Iff (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)))))) S (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (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)))))) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) S) T))
-Case conversion may be inaccurate. Consider using '#align submonoid.le_pointwise_smul_iff₀ Submonoid.le_pointwise_smul_iff₀ₓ'. -/
 theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff₀ ha
 #align submonoid.le_pointwise_smul_iff₀ Submonoid.le_pointwise_smul_iff₀
@@ -574,12 +364,6 @@ end GroupWithZero
 
 open Pointwise
 
-/- warning: submonoid.mem_closure_inv -> Submonoid.mem_closure_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Set.{u1} G) (x : G), Iff (Membership.Mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) x (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) S))) (Membership.Mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.hasMem.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)) x) (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) S))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Set.{u1} G) (x : G), Iff (Membership.mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.instSetLikeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) x (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_3))))) S))) (Membership.mem.{u1, u1} G (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.instMembership.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.instSetLikeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_3)))) x) (Submonoid.closure.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))) S))
-Case conversion may be inaccurate. Consider using '#align submonoid.mem_closure_inv Submonoid.mem_closure_invₓ'. -/
 @[to_additive]
 theorem mem_closure_inv {G : Type _} [Group G] (S : Set G) (x : G) :
     x ∈ Submonoid.closure S⁻¹ ↔ x⁻¹ ∈ Submonoid.closure S := by rw [closure_inv, mem_inv]
@@ -613,76 +397,34 @@ scoped[Pointwise] attribute [instance] AddSubmonoid.pointwiseMulAction
 
 open Pointwise
 
-/- warning: add_submonoid.coe_pointwise_smul -> AddSubmonoid.coe_pointwise_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (Set.{u2} A) ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Set.{u2} A) (HasLiftT.mk.{succ u2, succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Set.{u2} A) (CoeTCₓ.coe.{succ u2, succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Set.{u2} A) (SetLike.Set.hasCoeT.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a S)) (SMul.smul.{u1, u2} α (Set.{u2} A) (Set.smulSet.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4)))) a ((fun (a : Type.{u2}) (b : Type.{u2}) [self : HasLiftT.{succ u2, succ u2} a b] => self.0) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Set.{u2} A) (HasLiftT.mk.{succ u2, succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Set.{u2} A) (CoeTCₓ.coe.{succ u2, succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Set.{u2} A) (SetLike.Set.hasCoeT.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S))
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (Set.{u2} A) (SetLike.coe.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a S)) (HSMul.hSMul.{u1, u2, u2} α (Set.{u2} A) (Set.{u2} A) (instHSMul.{u1, u2} α (Set.{u2} A) (Set.smulSet.{u1, u2} α A (SMulZeroClass.toSMul.{u1, u2} α A (AddMonoid.toZero.{u2} A _inst_2) (DistribSMul.toSMulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4))))) a (SetLike.coe.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) S))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.coe_pointwise_smul AddSubmonoid.coe_pointwise_smulₓ'. -/
 @[simp]
 theorem coe_pointwise_smul (a : α) (S : AddSubmonoid A) : ↑(a • S) = a • (S : Set A) :=
   rfl
 #align add_submonoid.coe_pointwise_smul AddSubmonoid.coe_pointwise_smul
 
-/- warning: add_submonoid.smul_mem_pointwise_smul -> AddSubmonoid.smul_mem_pointwise_smul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (m : A) (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) m S) -> (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4))) a m) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a S))
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (m : A) (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) m S) -> (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (HSMul.hSMul.{u1, u2, u2} α A A (instHSMul.{u1, u2} α A (SMulZeroClass.toSMul.{u1, u2} α A (AddMonoid.toZero.{u2} A _inst_2) (DistribSMul.toSMulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4)))) a m) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a S))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.smul_mem_pointwise_smul AddSubmonoid.smul_mem_pointwise_smulₓ'. -/
 theorem smul_mem_pointwise_smul (m : A) (a : α) (S : AddSubmonoid A) : m ∈ S → a • m ∈ a • S :=
   (Set.smul_mem_smul_set : _ → _ ∈ a • (S : Set A))
 #align add_submonoid.smul_mem_pointwise_smul AddSubmonoid.smul_mem_pointwise_smul
 
-/- warning: add_submonoid.mem_smul_pointwise_iff_exists -> AddSubmonoid.mem_smul_pointwise_iff_exists is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (m : A) (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Iff (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) m (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a S)) (Exists.{succ u2} A (fun (s : A) => And (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) s S) (Eq.{succ u2} A (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4))) a s) m)))
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (m : A) (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Iff (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) m (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a S)) (Exists.{succ u2} A (fun (s : A) => And (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) s S) (Eq.{succ u2} A (HSMul.hSMul.{u1, u2, u2} α A A (instHSMul.{u1, u2} α A (SMulZeroClass.toSMul.{u1, u2} α A (AddMonoid.toZero.{u2} A _inst_2) (DistribSMul.toSMulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4)))) a s) m)))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mem_smul_pointwise_iff_exists AddSubmonoid.mem_smul_pointwise_iff_existsₓ'. -/
 theorem mem_smul_pointwise_iff_exists (m : A) (a : α) (S : AddSubmonoid A) :
     m ∈ a • S ↔ ∃ s : A, s ∈ S ∧ a • s = m :=
   (Set.mem_smul_set : m ∈ a • (S : Set A) ↔ _)
 #align add_submonoid.mem_smul_pointwise_iff_exists AddSubmonoid.mem_smul_pointwise_iff_exists
 
-/- warning: add_submonoid.smul_bot -> AddSubmonoid.smul_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a (Bot.bot.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.hasBot.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))) (Bot.bot.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.hasBot.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a (Bot.bot.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instBotAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))) (Bot.bot.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instBotAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.smul_bot AddSubmonoid.smul_botₓ'. -/
 @[simp]
 theorem smul_bot (a : α) : a • (⊥ : AddSubmonoid A) = ⊥ :=
   map_bot _
 #align add_submonoid.smul_bot AddSubmonoid.smul_bot
 
-/- warning: add_submonoid.smul_sup -> AddSubmonoid.smul_sup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.completeLattice.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)) (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.completeLattice.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a T))
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)) (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a T))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.smul_sup AddSubmonoid.smul_supₓ'. -/
 theorem smul_sup (a : α) (S T : AddSubmonoid A) : a • (S ⊔ T) = a • S ⊔ a • T :=
   map_sup _ _ _
 #align add_submonoid.smul_sup AddSubmonoid.smul_sup
 
-/- warning: add_submonoid.smul_closure -> AddSubmonoid.smul_closure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (s : Set.{u2} A), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a (AddSubmonoid.closure.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2) s)) (AddSubmonoid.closure.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (SMul.smul.{u1, u2} α (Set.{u2} A) (Set.smulSet.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4)))) a s))
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (s : Set.{u2} A), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a (AddSubmonoid.closure.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2) s)) (AddSubmonoid.closure.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (HSMul.hSMul.{u1, u2, u2} α (Set.{u2} A) (Set.{u2} A) (instHSMul.{u1, u2} α (Set.{u2} A) (Set.smulSet.{u1, u2} α A (SMulZeroClass.toSMul.{u1, u2} α A (AddMonoid.toZero.{u2} A _inst_2) (DistribSMul.toSMulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4))))) a s))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.smul_closure AddSubmonoid.smul_closureₓ'. -/
 @[simp]
 theorem smul_closure (a : α) (s : Set A) : a • closure s = closure (a • s) :=
   AddMonoidHom.map_mclosure _ _
 #align add_submonoid.smul_closure AddSubmonoid.smul_closure
 
-/- warning: add_submonoid.pointwise_central_scalar -> AddSubmonoid.pointwise_isCentralScalar is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] [_inst_5 : DistribMulAction.{u1, u2} (MulOpposite.{u1} α) A (MulOpposite.monoid.{u1} α _inst_3) _inst_2] [_inst_6 : IsCentralScalar.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4))) (SMulZeroClass.toHasSmul.{u1, u2} (MulOpposite.{u1} α) A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} (MulOpposite.{u1} α) A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} (MulOpposite.{u1} α) A (MulOpposite.monoid.{u1} α _inst_3) _inst_2 _inst_5)))], IsCentralScalar.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) (MulAction.toHasSmul.{u1, u2} (MulOpposite.{u1} α) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulOpposite.monoid.{u1} α _inst_3) (AddSubmonoid.pointwiseMulAction.{u1, u2} (MulOpposite.{u1} α) A _inst_2 (MulOpposite.monoid.{u1} α _inst_3) _inst_5))
-but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : Monoid.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A _inst_3 _inst_2] [_inst_5 : DistribMulAction.{u2, u1} (MulOpposite.{u2} α) A (MulOpposite.monoid.{u2} α _inst_3) _inst_2] [_inst_6 : IsCentralScalar.{u2, u1} α A (SMulZeroClass.toSMul.{u2, u1} α A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} α A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} α A _inst_3 _inst_2 _inst_4))) (SMulZeroClass.toSMul.{u2, u1} (MulOpposite.{u2} α) A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} (MulOpposite.{u2} α) A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} (MulOpposite.{u2} α) A (MulOpposite.monoid.{u2} α _inst_3) _inst_2 _inst_5)))], IsCentralScalar.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 _inst_3 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulOpposite.monoid.{u2} α _inst_3) (AddSubmonoid.pointwiseMulAction.{u2, u1} (MulOpposite.{u2} α) A _inst_2 (MulOpposite.monoid.{u2} α _inst_3) _inst_5))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_central_scalar AddSubmonoid.pointwise_isCentralScalarₓ'. -/
 instance pointwise_isCentralScalar [DistribMulAction αᵐᵒᵖ A] [IsCentralScalar α A] :
     IsCentralScalar α (AddSubmonoid A) :=
   ⟨fun a S =>
@@ -697,66 +439,30 @@ variable [Group α] [DistribMulAction α A]
 
 open Pointwise
 
-/- warning: add_submonoid.smul_mem_pointwise_smul_iff -> AddSubmonoid.smul_mem_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {x : A}, Iff (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2 _inst_4))) a x) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x S)
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {x : A}, Iff (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (HSMul.hSMul.{u1, u2, u2} α A A (instHSMul.{u1, u2} α A (SMulZeroClass.toSMul.{u1, u2} α A (AddMonoid.toZero.{u2} A _inst_2) (DistribSMul.toSMulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2 _inst_4)))) a x) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S)) (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x S)
-Case conversion may be inaccurate. Consider using '#align add_submonoid.smul_mem_pointwise_smul_iff AddSubmonoid.smul_mem_pointwise_smul_iffₓ'. -/
 @[simp]
 theorem smul_mem_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff
 #align add_submonoid.smul_mem_pointwise_smul_iff AddSubmonoid.smul_mem_pointwise_smul_iff
 
-/- warning: add_submonoid.mem_pointwise_smul_iff_inv_smul_mem -> AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {x : A}, Iff (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2 _inst_4))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) x) S)
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {x : A}, Iff (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S)) (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (HSMul.hSMul.{u1, u2, u2} α A A (instHSMul.{u1, u2} α A (SMulZeroClass.toSMul.{u1, u2} α A (AddMonoid.toZero.{u2} A _inst_2) (DistribSMul.toSMulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2 _inst_4)))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) x) S)
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mem_pointwise_smul_iff_inv_smul_mem AddSubmonoid.mem_pointwise_smul_iff_inv_smul_memₓ'. -/
 theorem mem_pointwise_smul_iff_inv_smul_mem {a : α} {S : AddSubmonoid A} {x : A} :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem
 #align add_submonoid.mem_pointwise_smul_iff_inv_smul_mem AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem
 
-/- warning: add_submonoid.mem_inv_pointwise_smul_iff -> AddSubmonoid.mem_inv_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {x : A}, Iff (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S)) (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2 _inst_4))) a x) S)
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {x : A}, Iff (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) S)) (Membership.mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.instMembership.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (HSMul.hSMul.{u1, u2, u2} α A A (instHSMul.{u1, u2} α A (SMulZeroClass.toSMul.{u1, u2} α A (AddMonoid.toZero.{u2} A _inst_2) (DistribSMul.toSMulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2 _inst_4)))) a x) S)
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mem_inv_pointwise_smul_iff AddSubmonoid.mem_inv_pointwise_smul_iffₓ'. -/
 theorem mem_inv_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff
 #align add_submonoid.mem_inv_pointwise_smul_iff AddSubmonoid.mem_inv_pointwise_smul_iff
 
-/- warning: add_submonoid.pointwise_smul_le_pointwise_smul_iff -> AddSubmonoid.pointwise_smul_le_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S T)
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)
-Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_pointwise_smul_iff AddSubmonoid.pointwise_smul_le_pointwise_smul_iffₓ'. -/
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} :
     a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff
 #align add_submonoid.pointwise_smul_le_pointwise_smul_iff AddSubmonoid.pointwise_smul_le_pointwise_smul_iff
 
-/- warning: add_submonoid.pointwise_smul_le_iff -> AddSubmonoid.pointwise_smul_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) T))
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) T))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_iff AddSubmonoid.pointwise_smul_le_iffₓ'. -/
 theorem pointwise_smul_le_iff {a : α} {S T : AddSubmonoid A} : a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff
 #align add_submonoid.pointwise_smul_le_iff AddSubmonoid.pointwise_smul_le_iff
 
-/- warning: add_submonoid.le_pointwise_smul_iff -> AddSubmonoid.le_pointwise_smul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S) T)
-but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) S) T)
-Case conversion may be inaccurate. Consider using '#align add_submonoid.le_pointwise_smul_iff AddSubmonoid.le_pointwise_smul_iffₓ'. -/
 theorem le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} : S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff
 #align add_submonoid.le_pointwise_smul_iff AddSubmonoid.le_pointwise_smul_iff
@@ -769,69 +475,33 @@ variable [GroupWithZero α] [DistribMulAction α A]
 
 open Pointwise
 
-/- warning: add_submonoid.smul_mem_pointwise_smul_iff₀ -> AddSubmonoid.smul_mem_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (x : A), Iff (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2 _inst_4))) a x) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x S))
-but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall (S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (x : A), Iff (Membership.mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2))) (HSMul.hSMul.{u2, u1, u1} α A A (instHSMul.{u2, u1} α A (SMulZeroClass.toSMul.{u2, u1} α A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} α A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2 _inst_4)))) a x) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S)) (Membership.mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2))) x S))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.smul_mem_pointwise_smul_iff₀ AddSubmonoid.smul_mem_pointwise_smul_iff₀ₓ'. -/
 @[simp]
 theorem smul_mem_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
     a • x ∈ a • S ↔ x ∈ S :=
   smul_mem_smul_set_iff₀ ha (S : Set A) x
 #align add_submonoid.smul_mem_pointwise_smul_iff₀ AddSubmonoid.smul_mem_pointwise_smul_iff₀
 
-/- warning: add_submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ -> AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (x : A), Iff (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S)) (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2 _inst_4))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) x) S))
-but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall (S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (x : A), Iff (Membership.mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2))) x (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S)) (Membership.mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2))) (HSMul.hSMul.{u2, u1, u1} α A A (instHSMul.{u2, u1} α A (SMulZeroClass.toSMul.{u2, u1} α A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} α A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2 _inst_4)))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) x) S))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem₀ₓ'. -/
 theorem mem_pointwise_smul_iff_inv_smul_mem₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
     x ∈ a • S ↔ a⁻¹ • x ∈ S :=
   mem_smul_set_iff_inv_smul_mem₀ ha (S : Set A) x
 #align add_submonoid.mem_pointwise_smul_iff_inv_smul_mem₀ AddSubmonoid.mem_pointwise_smul_iff_inv_smul_mem₀
 
-/- warning: add_submonoid.mem_inv_pointwise_smul_iff₀ -> AddSubmonoid.mem_inv_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (x : A), Iff (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) x (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S)) (Membership.Mem.{u2, u2} A (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.hasMem.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))) (SMul.smul.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2 _inst_4))) a x) S))
-but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall (S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (x : A), Iff (Membership.mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2))) x (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) S)) (Membership.mem.{u1, u1} A (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) A (AddSubmonoid.instSetLikeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2))) (HSMul.hSMul.{u2, u1, u1} α A A (instHSMul.{u2, u1} α A (SMulZeroClass.toSMul.{u2, u1} α A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} α A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2 _inst_4)))) a x) S))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mem_inv_pointwise_smul_iff₀ AddSubmonoid.mem_inv_pointwise_smul_iff₀ₓ'. -/
 theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid A) (x : A) :
     x ∈ a⁻¹ • S ↔ a • x ∈ S :=
   mem_inv_smul_set_iff₀ ha (S : Set A) x
 #align add_submonoid.mem_inv_pointwise_smul_iff₀ AddSubmonoid.mem_inv_pointwise_smul_iff₀
 
-/- warning: add_submonoid.pointwise_smul_le_pointwise_smul_iff₀ -> AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S T))
-but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)} {T : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)}, Iff (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) S T))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_pointwise_smul_iff₀ AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀ₓ'. -/
 @[simp]
 theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
     a • S ≤ a • T ↔ S ≤ T :=
   set_smul_subset_set_smul_iff₀ ha
 #align add_submonoid.pointwise_smul_le_pointwise_smul_iff₀ AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀
 
-/- warning: add_submonoid.pointwise_smul_le_iff₀ -> AddSubmonoid.pointwise_smul_le_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) T)))
-but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)} {T : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)}, Iff (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) T) (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) S (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) T)))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_iff₀ AddSubmonoid.pointwise_smul_le_iff₀ₓ'. -/
 theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
     a • S ≤ T ↔ S ≤ a⁻¹ • T :=
   set_smul_subset_iff₀ ha
 #align add_submonoid.pointwise_smul_le_iff₀ AddSubmonoid.pointwise_smul_le_iff₀
 
-/- warning: add_submonoid.le_pointwise_smul_iff₀ -> AddSubmonoid.le_pointwise_smul_iff₀ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S) T))
-but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)} {T : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)}, Iff (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) S (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) S) T))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.le_pointwise_smul_iff₀ AddSubmonoid.le_pointwise_smul_iff₀ₓ'. -/
 theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A} :
     S ≤ a • T ↔ a⁻¹ • S ≤ T :=
   subset_set_smul_iff₀ ha
@@ -864,22 +534,10 @@ theorem one_eq_mrange : (1 : AddSubmonoid R) = (Nat.castAddMonoidHom R).mrange :
 #align add_submonoid.one_eq_mrange AddSubmonoid.one_eq_mrange
 -/
 
-/- warning: add_submonoid.nat_cast_mem_one -> AddSubmonoid.natCast_mem_one is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : AddMonoidWithOne.{u1} R] (n : Nat), Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3)))) ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat R (HasLiftT.mk.{1, succ u1} Nat R (CoeTCₓ.coe.{1, succ u1} Nat R (Nat.castCoe.{u1} R (AddMonoidWithOne.toNatCast.{u1} R _inst_3)))) n) (OfNat.ofNat.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) 1 (OfNat.mk.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) 1 (One.one.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (AddSubmonoid.hasOne.{u1} R _inst_3))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : AddMonoidWithOne.{u1} R] (n : Nat), Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3)))) (Nat.cast.{u1} R (AddMonoidWithOne.toNatCast.{u1} R _inst_3) n) (OfNat.ofNat.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) 1 (One.toOfNat1.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (AddSubmonoid.one.{u1} R _inst_3)))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.nat_cast_mem_one AddSubmonoid.natCast_mem_oneₓ'. -/
 theorem natCast_mem_one (n : ℕ) : (n : R) ∈ (1 : AddSubmonoid R) :=
   ⟨_, rfl⟩
 #align add_submonoid.nat_cast_mem_one AddSubmonoid.natCast_mem_one
 
-/- warning: add_submonoid.mem_one -> AddSubmonoid.mem_one is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : AddMonoidWithOne.{u1} R] {x : R}, Iff (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3)))) x (OfNat.ofNat.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) 1 (OfNat.mk.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) 1 (One.one.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (AddSubmonoid.hasOne.{u1} R _inst_3))))) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} R ((fun (a : Type) (b : Type.{u1}) [self : HasLiftT.{1, succ u1} a b] => self.0) Nat R (HasLiftT.mk.{1, succ u1} Nat R (CoeTCₓ.coe.{1, succ u1} Nat R (Nat.castCoe.{u1} R (AddMonoidWithOne.toNatCast.{u1} R _inst_3)))) n) x))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : AddMonoidWithOne.{u1} R] {x : R}, Iff (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3)))) x (OfNat.ofNat.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) 1 (One.toOfNat1.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R _inst_3))) (AddSubmonoid.one.{u1} R _inst_3)))) (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} R (Nat.cast.{u1} R (AddMonoidWithOne.toNatCast.{u1} R _inst_3) n) x))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mem_one AddSubmonoid.mem_oneₓ'. -/
 @[simp]
 theorem mem_one {x : R} : x ∈ (1 : AddSubmonoid R) ↔ ∃ n : ℕ, ↑n = x :=
   Iff.rfl
@@ -911,33 +569,15 @@ smallest R-submodule of `R` containing the elements `s * t` for `s ∈ S` and `t
 instance : Mul (AddSubmonoid R) :=
   ⟨fun M N => ⨆ s : M, N.map <| AddMonoidHom.mul s.1⟩
 
-/- warning: add_submonoid.mul_mem_mul -> AddSubmonoid.mul_mem_mul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {m : R} {n : R}, (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3))) m n) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {m : R} {n : R}, (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3)) m n) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_mem_mul AddSubmonoid.mul_mem_mulₓ'. -/
 theorem mul_mem_mul {M N : AddSubmonoid R} {m n : R} (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N :=
   (le_iSup _ ⟨m, hm⟩ : _ ≤ M * N) ⟨n, hn, rfl⟩
 #align add_submonoid.mul_mem_mul AddSubmonoid.mul_mem_mul
 
-/- warning: add_submonoid.mul_le -> AddSubmonoid.mul_le is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, Iff (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) P) (forall (m : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (forall (n : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3))) m n) P)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, Iff (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N) P) (forall (m : R), (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (forall (n : R), (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3)) m n) P)))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le AddSubmonoid.mul_leₓ'. -/
 theorem mul_le {M N P : AddSubmonoid R} : M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P :=
   ⟨fun H m hm n hn => H <| mul_mem_mul hm hn, fun H =>
     iSup_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
 #align add_submonoid.mul_le AddSubmonoid.mul_le
 
-/- warning: add_submonoid.mul_induction_on -> AddSubmonoid.mul_induction_on is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {C : R -> Prop} {r : R}, (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) r (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N)) -> (forall (m : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (forall (n : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (C (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3))) m n)))) -> (forall (x : R) (y : R), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toHasAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3))) x y))) -> (C r)
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {C : R -> Prop} {r : R}, (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) r (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N)) -> (forall (m : R), (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (forall (n : R), (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (C (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3)) m n)))) -> (forall (x : R) (y : R), (C x) -> (C y) -> (C (HAdd.hAdd.{u1, u1, u1} R R R (instHAdd.{u1} R (Distrib.toAdd.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3))) x y))) -> (C r)
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_induction_on AddSubmonoid.mul_induction_onₓ'. -/
 @[elab_as_elim]
 protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r : R} (hr : r ∈ M * N)
     (hm : ∀ m ∈ M, ∀ n ∈ N, C (m * n)) (ha : ∀ x y, C x → C y → C (x + y)) : C r :=
@@ -948,12 +588,6 @@ protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r :
 
 open Pointwise
 
-/- warning: add_submonoid.closure_mul_closure -> AddSubmonoid.closure_mul_closure is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (S : Set.{u1} R) (T : Set.{u1} R), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) S) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) T)) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3)))) S T))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (S : Set.{u1} R) (T : Set.{u1} R), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) S) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) T)) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3))) S T))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.closure_mul_closure AddSubmonoid.closure_mul_closureₓ'. -/
 -- this proof is copied directly from `submodule.span_mul_span`
 theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S * T) :=
   by
@@ -973,74 +607,35 @@ theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S *
     exact mul_mem_mul (subset_closure ha) (subset_closure hb)
 #align add_submonoid.closure_mul_closure AddSubmonoid.closure_mul_closure
 
-/- warning: add_submonoid.mul_eq_closure_mul_set -> AddSubmonoid.mul_eq_closure_mul_set is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N)))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) M) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) N)))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_eq_closure_mul_set AddSubmonoid.mul_eq_closure_mul_setₓ'. -/
 theorem mul_eq_closure_mul_set (M N : AddSubmonoid R) : M * N = closure (M * N) := by
   rw [← closure_mul_closure, closure_eq, closure_eq]
 #align add_submonoid.mul_eq_closure_mul_set AddSubmonoid.mul_eq_closure_mul_set
 
-/- warning: add_submonoid.mul_bot -> AddSubmonoid.mul_bot is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (S : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) S (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasBot.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))) (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasBot.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (S : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) S (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instBotAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))) (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instBotAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_bot AddSubmonoid.mul_botₓ'. -/
 @[simp]
 theorem mul_bot (S : AddSubmonoid R) : S * ⊥ = ⊥ :=
   eq_bot_iff.2 <|
     mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hn⊢ <;> rw [hn, MulZeroClass.mul_zero]
 #align add_submonoid.mul_bot AddSubmonoid.mul_bot
 
-/- warning: add_submonoid.bot_mul -> AddSubmonoid.bot_mul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (S : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasBot.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) S) (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasBot.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] (S : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instBotAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) S) (Bot.bot.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instBotAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.bot_mul AddSubmonoid.bot_mulₓ'. -/
 @[simp]
 theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ :=
   eq_bot_iff.2 <|
     mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hm⊢ <;> rw [hm, MulZeroClass.zero_mul]
 #align add_submonoid.bot_mul AddSubmonoid.bot_mul
 
-/- warning: add_submonoid.mul_le_mul -> AddSubmonoid.mul_le_mul is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le_mul AddSubmonoid.mul_le_mulₓ'. -/
 @[mono]
 theorem mul_le_mul {M N P Q : AddSubmonoid R} (hmp : M ≤ P) (hnq : N ≤ Q) : M * N ≤ P * Q :=
   mul_le.2 fun m hm n hn => mul_mem_mul (hmp hm) (hnq hn)
 #align add_submonoid.mul_le_mul AddSubmonoid.mul_le_mul
 
-/- warning: add_submonoid.mul_le_mul_left -> AddSubmonoid.mul_le_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M N) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M P) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) N P))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) M N) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M P) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) N P))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le_mul_left AddSubmonoid.mul_le_mul_leftₓ'. -/
 theorem mul_le_mul_left {M N P : AddSubmonoid R} (h : M ≤ N) : M * P ≤ N * P :=
   mul_le_mul h (le_refl P)
 #align add_submonoid.mul_le_mul_left AddSubmonoid.mul_le_mul_left
 
-/- warning: add_submonoid.mul_le_mul_right -> AddSubmonoid.mul_le_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M P))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) N P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M P))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le_mul_right AddSubmonoid.mul_le_mul_rightₓ'. -/
 theorem mul_le_mul_right {M N P : AddSubmonoid R} (h : N ≤ P) : M * N ≤ M * P :=
   mul_le_mul (le_refl M) h
 #align add_submonoid.mul_le_mul_right AddSubmonoid.mul_le_mul_right
 
-/- warning: add_submonoid.mul_subset_mul -> AddSubmonoid.mul_subset_mul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) M) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) N)) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_subset_mul AddSubmonoid.mul_subset_mulₓ'. -/
 theorem mul_subset_mul {M N : AddSubmonoid R} : (↑M : Set R) * (↑N : Set R) ⊆ (↑(M * N) : Set R) :=
   by rintro _ ⟨i, j, hi, hj, rfl⟩; exact mul_mem_mul hi hj
 #align add_submonoid.mul_subset_mul AddSubmonoid.mul_subset_mul
@@ -1051,12 +646,6 @@ section NonUnitalNonAssocRing
 
 variable [NonUnitalNonAssocRing R]
 
-/- warning: add_submonoid.has_distrib_neg -> AddSubmonoid.hasDistribNeg is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocRing.{u1} R], HasDistribNeg.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (NonUnitalNonAssocRing.toAddCommGroup.{u1} R _inst_3)))))) (AddSubmonoid.hasMul.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R _inst_3))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocRing.{u1} R], HasDistribNeg.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (SubNegMonoid.toAddMonoid.{u1} R (AddGroup.toSubNegMonoid.{u1} R (AddCommGroup.toAddGroup.{u1} R (NonUnitalNonAssocRing.toAddCommGroup.{u1} R _inst_3)))))) (AddSubmonoid.mul.{u1} R (NonUnitalNonAssocRing.toNonUnitalNonAssocSemiring.{u1} R _inst_3))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.has_distrib_neg AddSubmonoid.hasDistribNegₓ'. -/
 /-- `add_submonoid.has_pointwise_neg` distributes over multiplication.
 
 This is available as an instance in the `pointwise` locale. -/
@@ -1127,33 +716,15 @@ instance : Monoid (AddSubmonoid R) :=
     one := 1
     mul := (· * ·) }
 
-/- warning: add_submonoid.closure_pow -> AddSubmonoid.closure_pow is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] (s : Set.{u1} R) (n : Nat), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) s) n) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))) (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) s n))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] (s : Set.{u1} R) (n : Nat), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) s) n) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (Semiring.toOne.{u1} R _inst_3) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) s n))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.closure_pow AddSubmonoid.closure_powₓ'. -/
 theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)
   | 0 => by rw [pow_zero, pow_zero, one_eq_closure_one_set]
   | n + 1 => by rw [pow_succ, pow_succ, closure_pow, closure_mul_closure]
 #align add_submonoid.closure_pow AddSubmonoid.closure_pow
 
-/- warning: add_submonoid.pow_eq_closure_pow_set -> AddSubmonoid.pow_eq_closure_pow_set is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] (s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (n : Nat), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))) (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))))))) s) n))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] (s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (n : Nat), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (Semiring.toOne.{u1} R _inst_3) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) s) n))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.pow_eq_closure_pow_set AddSubmonoid.pow_eq_closure_pow_setₓ'. -/
 theorem pow_eq_closure_pow_set (s : AddSubmonoid R) (n : ℕ) : s ^ n = closure ((s : Set R) ^ n) :=
   by rw [← closure_pow, closure_eq]
 #align add_submonoid.pow_eq_closure_pow_set AddSubmonoid.pow_eq_closure_pow_set
 
-/- warning: add_submonoid.pow_subset_pow -> AddSubmonoid.pow_subset_pow is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] {s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))} {n : Nat}, HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))) (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))))))) s) n) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] {s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))} {n : Nat}, HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (Semiring.toOne.{u1} R _inst_3) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) s) n) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n))
-Case conversion may be inaccurate. Consider using '#align add_submonoid.pow_subset_pow AddSubmonoid.pow_subset_powₓ'. -/
 theorem pow_subset_pow {s : AddSubmonoid R} {n : ℕ} : (↑s : Set R) ^ n ⊆ ↑(s ^ n) :=
   (pow_eq_closure_pow_set s n).symm ▸ subset_closure
 #align add_submonoid.pow_subset_pow AddSubmonoid.pow_subset_pow
@@ -1166,12 +737,6 @@ namespace Set.IsPwo
 
 variable [OrderedCancelCommMonoid α] {s : Set α}
 
-/- warning: set.is_pwo.submonoid_closure -> Set.IsPwo.submonoid_closure is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_3 : OrderedCancelCommMonoid.{u1} α] {s : Set.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) x)) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) s) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) α (Submonoid.setLike.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) (Submonoid.closure.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))) s)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_3 : OrderedCancelCommMonoid.{u1} α] {s : Set.{u1} α}, (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (RightCancelMonoid.toOne.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) x)) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) s) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) (SetLike.coe.{u1, u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) α (Submonoid.instSetLikeSubmonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Submonoid.closure.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))) s)))
-Case conversion may be inaccurate. Consider using '#align set.is_pwo.submonoid_closure Set.IsPwo.submonoid_closureₓ'. -/
 @[to_additive]
 theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPwo) :
     IsPwo (Submonoid.closure s : Set α) :=

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

@@ -72,10 +72,8 @@ but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] {s : Set.{u1} M} {t : Set.{u1} M} {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) s (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)) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) t (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)) -> (HasSubset.Subset.{u1} (Set.{u1} M) (Set.instHasSubsetSet.{u1} M) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) s t) (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))
 Case conversion may be inaccurate. Consider using '#align submonoid.mul_subset Submonoid.mul_subsetₓ'. -/
 @[to_additive]
-theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S :=
-  by
-  rintro _ ⟨p, q, hp, hq, rfl⟩
-  exact Submonoid.mul_mem _ (hs hp) (ht hq)
+theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S := by
+  rintro _ ⟨p, q, hp, hq, rfl⟩; exact Submonoid.mul_mem _ (hs hp) (ht hq)
 #align submonoid.mul_subset Submonoid.mul_subset
 #align add_submonoid.add_subset AddSubmonoid.add_subset
 
@@ -168,14 +166,9 @@ open Pointwise
 protected def inv : Inv (Submonoid G)
     where inv S :=
     { carrier := (S : Set G)⁻¹
-      one_mem' :=
-        show (1 : G)⁻¹ ∈ S by
-          rw [inv_one]
-          exact S.one_mem
+      one_mem' := show (1 : G)⁻¹ ∈ S by rw [inv_one]; exact S.one_mem
       mul_mem' := fun a b (ha : a⁻¹ ∈ S) (hb : b⁻¹ ∈ S) =>
-        show (a * b)⁻¹ ∈ S by
-          rw [mul_inv_rev]
-          exact S.mul_mem hb ha }
+        show (a * b)⁻¹ ∈ S by rw [mul_inv_rev]; exact S.mul_mem hb ha }
 #align submonoid.has_inv Submonoid.inv
 #align add_submonoid.has_neg AddSubmonoid.neg
 -/
@@ -351,9 +344,7 @@ This is available as an instance in the `pointwise` locale. -/
 protected def pointwiseMulAction : MulAction α (Submonoid M)
     where
   smul a S := S.map (MulDistribMulAction.toMonoidEnd _ M a)
-  one_smul S := by
-    ext
-    simp
+  one_smul S := by ext; simp
   mul_smul a₁ a₂ S :=
     (congr_arg (fun f : Monoid.End M => S.map f) (MonoidHom.map_mul _ _ _)).trans
       (S.map_map _ _).symm
@@ -967,8 +958,7 @@ Case conversion may be inaccurate. Consider using '#align add_submonoid.closure_
 theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S * T) :=
   by
   apply le_antisymm
-  · rw [mul_le]
-    intro a ha b hb
+  · rw [mul_le]; intro a ha b hb
     apply closure_induction ha
     on_goal 1 =>
       intros ; apply closure_induction hb
@@ -979,8 +969,7 @@ theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S *
         solve_by_elim (config :=
           { max_depth := 4
             discharger := tactic.interactive.apply_instance }) [add_mem _ _, zero_mem _]
-  · rw [closure_le]
-    rintro _ ⟨a, b, ha, hb, rfl⟩
+  · rw [closure_le]; rintro _ ⟨a, b, ha, hb, rfl⟩
     exact mul_mem_mul (subset_closure ha) (subset_closure hb)
 #align add_submonoid.closure_mul_closure AddSubmonoid.closure_mul_closure
 
@@ -1053,9 +1042,7 @@ but is expected to have type
   forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) (HMul.hMul.{u1, u1, u1} (Set.{u1} R) (Set.{u1} R) (Set.{u1} R) (instHMul.{u1} (Set.{u1} R) (Set.mul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) M) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) N)) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_subset_mul AddSubmonoid.mul_subset_mulₓ'. -/
 theorem mul_subset_mul {M N : AddSubmonoid R} : (↑M : Set R) * (↑N : Set R) ⊆ (↑(M * N) : Set R) :=
-  by
-  rintro _ ⟨i, j, hi, hj, rfl⟩
-  exact mul_mem_mul hi hj
+  by rintro _ ⟨i, j, hi, hj, rfl⟩; exact mul_mem_mul hi hj
 #align add_submonoid.mul_subset_mul AddSubmonoid.mul_subset_mul
 
 end NonUnitalNonAssocSemiring

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

@@ -1019,10 +1019,7 @@ theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ :=
 #align add_submonoid.bot_mul AddSubmonoid.bot_mul
 
 /- warning: add_submonoid.mul_le_mul -> AddSubmonoid.mul_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {Q : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N Q) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) P Q))
-but is expected to have type
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {Q : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) M P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) N Q) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) P Q))
+<too large>
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le_mul AddSubmonoid.mul_le_mulₓ'. -/
 @[mono]
 theorem mul_le_mul {M N P Q : AddSubmonoid R} (hmp : M ≤ P) (hnq : N ≤ Q) : M * N ≤ P * Q :=

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

@@ -109,7 +109,7 @@ theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s :=
 
 /- warning: submonoid.closure_mul_le -> Submonoid.closure_mul_le is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
 but is expected to have type
   forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
 Case conversion may be inaccurate. Consider using '#align submonoid.closure_mul_le Submonoid.closure_mul_leₓ'. -/
@@ -214,7 +214,7 @@ instance : InvolutiveInv (Submonoid G) :=
 
 /- warning: submonoid.inv_le_inv -> Submonoid.inv_le_inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T)) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) S T)
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T)) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) S T)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T)) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)
 Case conversion may be inaccurate. Consider using '#align submonoid.inv_le_inv Submonoid.inv_le_invₓ'. -/
@@ -226,7 +226,7 @@ theorem inv_le_inv (S T : Submonoid G) : S⁻¹ ≤ T⁻¹ ↔ S ≤ T :=
 
 /- warning: submonoid.inv_le -> Submonoid.inv_le is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) T) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) S (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) T) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) S (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Iff (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) T) (LE.le.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
 Case conversion may be inaccurate. Consider using '#align submonoid.inv_le Submonoid.inv_leₓ'. -/
@@ -238,7 +238,7 @@ theorem inv_le (S T : Submonoid G) : S⁻¹ ≤ T ↔ S ≤ T⁻¹ :=
 
 /- warning: submonoid.inv_order_iso -> Submonoid.invOrderIso is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], OrderIso.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], OrderIso.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))) (Preorder.toHasLe.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SetLike.partialOrder.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) G (Submonoid.setLike.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_3 : Group.{u1} G], OrderIso.{u1, u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Preorder.toLE.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (PartialOrder.toPreorder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))))))
 Case conversion may be inaccurate. Consider using '#align submonoid.inv_order_iso Submonoid.invOrderIsoₓ'. -/
@@ -476,7 +476,7 @@ theorem mem_inv_pointwise_smul_iff {a : α} {S : Submonoid M} {x : M} : x ∈ a
 
 /- warning: submonoid.pointwise_smul_le_pointwise_smul_iff -> Submonoid.pointwise_smul_le_pointwise_smul_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S T)
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S T)
 but is expected to have type
   forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)
 Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_le_pointwise_smul_iff Submonoid.pointwise_smul_le_pointwise_smul_iffₓ'. -/
@@ -487,7 +487,7 @@ theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : Submonoid M} : a 
 
 /- warning: submonoid.pointwise_smul_subset_iff -> Submonoid.pointwise_smul_subset_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) T))
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) T))
 but is expected to have type
   forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) T))
 Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_subset_iff Submonoid.pointwise_smul_subset_iffₓ'. -/
@@ -497,7 +497,7 @@ theorem pointwise_smul_subset_iff {a : α} {S T : Submonoid M} : a • S ≤ T 
 
 /- warning: submonoid.subset_pointwise_smul_iff -> Submonoid.subset_pointwise_smul_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S) T)
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S) T)
 but is expected to have type
   forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Group.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_1] {a : α} {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteSemilatticeInf.toPartialOrder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) S) T)
 Case conversion may be inaccurate. Consider using '#align submonoid.subset_pointwise_smul_iff Submonoid.subset_pointwise_smul_iffₓ'. -/
@@ -549,7 +549,7 @@ theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : Submonoid M)
 
 /- warning: submonoid.pointwise_smul_le_pointwise_smul_iff₀ -> Submonoid.pointwise_smul_le_pointwise_smul_iff₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S T))
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S T))
 but is expected to have type
   forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} {T : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, Iff (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)))))) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (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)))))) S T))
 Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_le_pointwise_smul_iff₀ Submonoid.pointwise_smul_le_pointwise_smul_iff₀ₓ'. -/
@@ -561,7 +561,7 @@ theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : S
 
 /- warning: submonoid.pointwise_smul_le_iff₀ -> Submonoid.pointwise_smul_le_iff₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) T)))
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) T)))
 but is expected to have type
   forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} {T : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, Iff (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)))))) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) T) (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)))))) S (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) T)))
 Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_smul_le_iff₀ Submonoid.pointwise_smul_le_iff₀ₓ'. -/
@@ -571,7 +571,7 @@ theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : a
 
 /- warning: submonoid.le_pointwise_smul_iff₀ -> Submonoid.le_pointwise_smul_iff₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toLE.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S) T))
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)} {T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)}, Iff (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) S (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Preorder.toHasLe.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (PartialOrder.toPreorder.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SetLike.partialOrder.{u2, u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) M (Submonoid.setLike.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S) T))
 but is expected to have type
   forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_1] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)} {T : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)}, Iff (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)))))) S (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (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)))))) (HSMul.hSMul.{u2, u1, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (instHSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) S) T))
 Case conversion may be inaccurate. Consider using '#align submonoid.le_pointwise_smul_iff₀ Submonoid.le_pointwise_smul_iff₀ₓ'. -/
@@ -740,7 +740,7 @@ theorem mem_inv_pointwise_smul_iff {a : α} {S : AddSubmonoid A} {x : A} : x ∈
 
 /- warning: add_submonoid.pointwise_smul_le_pointwise_smul_iff -> AddSubmonoid.pointwise_smul_le_pointwise_smul_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S T)
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S T)
 but is expected to have type
   forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)
 Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_pointwise_smul_iff AddSubmonoid.pointwise_smul_le_pointwise_smul_iffₓ'. -/
@@ -752,7 +752,7 @@ theorem pointwise_smul_le_pointwise_smul_iff {a : α} {S T : AddSubmonoid A} :
 
 /- warning: add_submonoid.pointwise_smul_le_iff -> AddSubmonoid.pointwise_smul_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) T))
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) T))
 but is expected to have type
   forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) T))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_iff AddSubmonoid.pointwise_smul_le_iffₓ'. -/
@@ -762,7 +762,7 @@ theorem pointwise_smul_le_iff {a : α} {S T : AddSubmonoid A} : a • S ≤ T 
 
 /- warning: add_submonoid.le_pointwise_smul_iff -> AddSubmonoid.le_pointwise_smul_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S) T)
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) a) S) T)
 but is expected to have type
   forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Group.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_2] {a : α} {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_3)) _inst_4))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_3)))) a) S) T)
 Case conversion may be inaccurate. Consider using '#align add_submonoid.le_pointwise_smul_iff AddSubmonoid.le_pointwise_smul_iffₓ'. -/
@@ -814,7 +814,7 @@ theorem mem_inv_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) (S : AddSubmonoid
 
 /- warning: add_submonoid.pointwise_smul_le_pointwise_smul_iff₀ -> AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S T))
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S T))
 but is expected to have type
   forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)} {T : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)}, Iff (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) S T))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_pointwise_smul_iff₀ AddSubmonoid.pointwise_smul_le_pointwise_smul_iff₀ₓ'. -/
@@ -826,7 +826,7 @@ theorem pointwise_smul_le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : A
 
 /- warning: add_submonoid.pointwise_smul_le_iff₀ -> AddSubmonoid.pointwise_smul_le_iff₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) T)))
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a S) T) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) T)))
 but is expected to have type
   forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)} {T : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)}, Iff (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a S) T) (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) S (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) T)))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_smul_le_iff₀ AddSubmonoid.pointwise_smul_le_iff₀ₓ'. -/
@@ -837,7 +837,7 @@ theorem pointwise_smul_le_iff₀ {a : α} (ha : a ≠ 0) {S T : AddSubmonoid A}
 
 /- warning: add_submonoid.le_pointwise_smul_iff₀ -> AddSubmonoid.le_pointwise_smul_iff₀ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toLE.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S) T))
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : GroupWithZero.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u1} α a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)))))))) -> (forall {S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)} {T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)}, Iff (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) S (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) a T)) (LE.le.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Preorder.toHasLe.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (PartialOrder.toPreorder.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SetLike.partialOrder.{u2, u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) A (AddSubmonoid.setLike.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 (MonoidWithZero.toMonoid.{u1} α (GroupWithZero.toMonoidWithZero.{u1} α _inst_3)) _inst_4)) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (GroupWithZero.toDivInvMonoid.{u1} α _inst_3)) a) S) T))
 but is expected to have type
   forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : GroupWithZero.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_2] {a : α}, (Ne.{succ u2} α a (OfNat.ofNat.{u2} α 0 (Zero.toOfNat0.{u2} α (MonoidWithZero.toZero.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3))))) -> (forall {S : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)} {T : AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)}, Iff (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) S (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) a T)) (LE.le.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (Preorder.toLE.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)))))) (HSMul.hSMul.{u2, u1, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (instHSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 (MonoidWithZero.toMonoid.{u2} α (GroupWithZero.toMonoidWithZero.{u2} α _inst_3)) _inst_4))) (Inv.inv.{u2} α (GroupWithZero.toInv.{u2} α _inst_3) a) S) T))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.le_pointwise_smul_iff₀ AddSubmonoid.le_pointwise_smul_iff₀ₓ'. -/
@@ -932,7 +932,7 @@ theorem mul_mem_mul {M N : AddSubmonoid R} {m n : R} (hm : m ∈ M) (hn : n ∈
 
 /- warning: add_submonoid.mul_le -> AddSubmonoid.mul_le is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, Iff (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) P) (forall (m : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (forall (n : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3))) m n) P)))
+  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, Iff (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) P) (forall (m : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (forall (n : R), (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.Mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.hasMem.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R _inst_3))) m n) P)))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, Iff (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N) P) (forall (m : R), (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (forall (n : R), (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3)) m n) P)))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le AddSubmonoid.mul_leₓ'. -/
@@ -1020,7 +1020,7 @@ theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ :=
 
 /- warning: add_submonoid.mul_le_mul -> AddSubmonoid.mul_le_mul is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {Q : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N Q) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) P Q))
+  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {Q : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N Q) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) P Q))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {Q : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) M P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) N Q) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) P Q))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le_mul AddSubmonoid.mul_le_mulₓ'. -/
@@ -1031,7 +1031,7 @@ theorem mul_le_mul {M N P Q : AddSubmonoid R} (hmp : M ≤ P) (hnq : N ≤ Q) :
 
 /- warning: add_submonoid.mul_le_mul_left -> AddSubmonoid.mul_le_mul_left is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M N) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M P) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) N P))
+  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) M N) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M P) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) N P))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) M N) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M P) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) N P))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le_mul_left AddSubmonoid.mul_le_mul_leftₓ'. -/
@@ -1041,7 +1041,7 @@ theorem mul_le_mul_left {M N P : AddSubmonoid R} (h : M ≤ N) : M * P ≤ N * P
 
 /- warning: add_submonoid.mul_le_mul_right -> AddSubmonoid.mul_le_mul_right is a dubious translation:
 lean 3 declaration is
-  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M P))
+  forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) N P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toHasLe.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.partialOrder.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.hasMul.{u1} R _inst_3)) M P))
 but is expected to have type
   forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {P : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))}, (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) N P) -> (LE.le.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (Preorder.toLE.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (PartialOrder.toPreorder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteSemilatticeInf.toPartialOrder.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (CompleteLattice.toCompleteSemilatticeInf.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))))))) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M P))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le_mul_right AddSubmonoid.mul_le_mul_rightₓ'. -/
@@ -1184,7 +1184,7 @@ variable [OrderedCancelCommMonoid α] {s : Set α}
 
 /- warning: set.is_pwo.submonoid_closure -> Set.IsPwo.submonoid_closure is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_3 : OrderedCancelCommMonoid.{u1} α] {s : Set.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) x)) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) s) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) α (Submonoid.setLike.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) (Submonoid.closure.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))) s)))
+  forall {α : Type.{u1}} [_inst_3 : OrderedCancelCommMonoid.{u1} α] {s : Set.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) x)) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) s) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) α (Submonoid.setLike.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) (Submonoid.closure.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))) s)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_3 : OrderedCancelCommMonoid.{u1} α] {s : Set.{u1} α}, (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (RightCancelMonoid.toOne.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) x)) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) s) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) (SetLike.coe.{u1, u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) α (Submonoid.instSetLikeSubmonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Submonoid.closure.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))) s)))
 Case conversion may be inaccurate. Consider using '#align set.is_pwo.submonoid_closure Set.IsPwo.submonoid_closureₓ'. -/

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

@@ -115,7 +115,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align submonoid.closure_mul_le Submonoid.closure_mul_leₓ'. -/
 @[to_additive]
 theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T :=
-  infₛ_le fun x ⟨s, t, hs, ht, hx⟩ =>
+  sInf_le fun x ⟨s, t, hs, ht, hx⟩ =>
     hx ▸
       (closure S ⊔ closure T).mul_mem (SetLike.le_def.mp le_sup_left <| subset_closure hs)
         (SetLike.le_def.mp le_sup_right <| subset_closure ht)
@@ -316,25 +316,25 @@ theorem inv_top : (⊤ : Submonoid G)⁻¹ = ⊤ :=
 #align submonoid.inv_top Submonoid.inv_top
 #align add_submonoid.neg_top AddSubmonoid.neg_top
 
-#print Submonoid.inv_infᵢ /-
+#print Submonoid.inv_iInf /-
 @[simp, to_additive]
-theorem inv_infᵢ {ι : Sort _} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ :=
-  (invOrderIso : Submonoid G ≃o Submonoid G).map_infᵢ _
-#align submonoid.inv_infi Submonoid.inv_infᵢ
-#align add_submonoid.neg_infi AddSubmonoid.neg_infᵢ
+theorem inv_iInf {ι : Sort _} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ :=
+  (invOrderIso : Submonoid G ≃o Submonoid G).map_iInf _
+#align submonoid.inv_infi Submonoid.inv_iInf
+#align add_submonoid.neg_infi AddSubmonoid.neg_iInf
 -/
 
-/- warning: submonoid.inv_supr -> Submonoid.inv_supᵢ is a dubious translation:
+/- warning: submonoid.inv_supr -> Submonoid.inv_iSup is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (supᵢ.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => S i))) (supᵢ.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (S i)))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => S i))) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (S i)))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (supᵢ.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toSupSet.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => S i))) (supᵢ.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toSupSet.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (S i)))
-Case conversion may be inaccurate. Consider using '#align submonoid.inv_supr Submonoid.inv_supᵢₓ'. -/
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] {ι : Sort.{u2}} (S : ι -> (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3))))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toSupSet.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => S i))) (iSup.{u1, u2} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toSupSet.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))) ι (fun (i : ι) => Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (S i)))
+Case conversion may be inaccurate. Consider using '#align submonoid.inv_supr Submonoid.inv_iSupₓ'. -/
 @[simp, to_additive]
-theorem inv_supᵢ {ι : Sort _} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
-  (invOrderIso : Submonoid G ≃o Submonoid G).map_supᵢ _
-#align submonoid.inv_supr Submonoid.inv_supᵢ
-#align add_submonoid.neg_supr AddSubmonoid.neg_supᵢ
+theorem inv_iSup {ι : Sort _} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
+  (invOrderIso : Submonoid G ≃o Submonoid G).map_iSup _
+#align submonoid.inv_supr Submonoid.inv_iSup
+#align add_submonoid.neg_supr AddSubmonoid.neg_iSup
 
 end Submonoid
 
@@ -927,7 +927,7 @@ but is expected to have type
   forall {R : Type.{u1}} [_inst_3 : NonUnitalNonAssocSemiring.{u1} R] {M : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {N : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))} {m : R} {n : R}, (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) m M) -> (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) n N) -> (Membership.mem.{u1, u1} R (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (SetLike.instMembership.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3))))) (HMul.hMul.{u1, u1, u1} R R R (instHMul.{u1} R (NonUnitalNonAssocSemiring.toMul.{u1} R _inst_3)) m n) (HMul.hMul.{u1, u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (instHMul.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddCommMonoid.toAddMonoid.{u1} R (NonUnitalNonAssocSemiring.toAddCommMonoid.{u1} R _inst_3)))) (AddSubmonoid.mul.{u1} R _inst_3)) M N))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_mem_mul AddSubmonoid.mul_mem_mulₓ'. -/
 theorem mul_mem_mul {M N : AddSubmonoid R} {m n : R} (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N :=
-  (le_supᵢ _ ⟨m, hm⟩ : _ ≤ M * N) ⟨n, hn, rfl⟩
+  (le_iSup _ ⟨m, hm⟩ : _ ≤ M * N) ⟨n, hn, rfl⟩
 #align add_submonoid.mul_mem_mul AddSubmonoid.mul_mem_mul
 
 /- warning: add_submonoid.mul_le -> AddSubmonoid.mul_le is a dubious translation:
@@ -938,7 +938,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_le AddSubmonoid.mul_leₓ'. -/
 theorem mul_le {M N P : AddSubmonoid R} : M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P :=
   ⟨fun H m hm n hn => H <| mul_mem_mul hm hn, fun H =>
-    supᵢ_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
+    iSup_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
 #align add_submonoid.mul_le AddSubmonoid.mul_le
 
 /- warning: add_submonoid.mul_induction_on -> AddSubmonoid.mul_induction_on is a dubious translation:

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

@@ -427,7 +427,7 @@ theorem smul_closure (a : α) (s : Set M) : a • closure s = closure (a • s)
 lean 3 declaration is
   forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] [_inst_5 : MulDistribMulAction.{u1, u2} (MulOpposite.{u1} α) M (MulOpposite.monoid.{u1} α _inst_3) _inst_1] [_inst_6 : IsCentralScalar.{u1, u2} α M (MulAction.toHasSmul.{u1, u2} α M _inst_3 (MulDistribMulAction.toMulAction.{u1, u2} α M _inst_3 _inst_1 _inst_4)) (MulAction.toHasSmul.{u1, u2} (MulOpposite.{u1} α) M (MulOpposite.monoid.{u1} α _inst_3) (MulDistribMulAction.toMulAction.{u1, u2} (MulOpposite.{u1} α) M (MulOpposite.monoid.{u1} α _inst_3) _inst_1 _inst_5))], IsCentralScalar.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) (MulAction.toHasSmul.{u1, u2} (MulOpposite.{u1} α) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulOpposite.monoid.{u1} α _inst_3) (Submonoid.pointwiseMulAction.{u1, u2} (MulOpposite.{u1} α) M _inst_1 (MulOpposite.monoid.{u1} α _inst_3) _inst_5))
 but is expected to have type
-  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : Monoid.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M _inst_3 _inst_1] [_inst_5 : MulDistribMulAction.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) _inst_1] [_inst_6 : IsCentralScalar.{u2, u1} α M (MulAction.toSMul.{u2, u1} α M _inst_3 (MulDistribMulAction.toMulAction.{u2, u1} α M _inst_3 _inst_1 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) (MulDistribMulAction.toMulAction.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) _inst_1 _inst_5))], IsCentralScalar.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 _inst_3 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) (Submonoid.pointwiseMulAction.{u2, u1} (MulOpposite.{u2} α) M _inst_1 (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) _inst_5))
+  forall {α : Type.{u2}} {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] [_inst_3 : Monoid.{u2} α] [_inst_4 : MulDistribMulAction.{u2, u1} α M _inst_3 _inst_1] [_inst_5 : MulDistribMulAction.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.monoid.{u2} α _inst_3) _inst_1] [_inst_6 : IsCentralScalar.{u2, u1} α M (MulAction.toSMul.{u2, u1} α M _inst_3 (MulDistribMulAction.toMulAction.{u2, u1} α M _inst_3 _inst_1 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.monoid.{u2} α _inst_3) (MulDistribMulAction.toMulAction.{u2, u1} (MulOpposite.{u2} α) M (MulOpposite.monoid.{u2} α _inst_3) _inst_1 _inst_5))], IsCentralScalar.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulAction.toSMul.{u2, u1} α (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u2, u1} α M _inst_1 _inst_3 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (MulOpposite.monoid.{u2} α _inst_3) (Submonoid.pointwiseMulAction.{u2, u1} (MulOpposite.{u2} α) M _inst_1 (MulOpposite.monoid.{u2} α _inst_3) _inst_5))
 Case conversion may be inaccurate. Consider using '#align submonoid.pointwise_central_scalar Submonoid.pointwise_isCentralScalarₓ'. -/
 instance pointwise_isCentralScalar [MulDistribMulAction αᵐᵒᵖ M] [IsCentralScalar α M] :
     IsCentralScalar α (Submonoid M) :=
@@ -690,7 +690,7 @@ theorem smul_closure (a : α) (s : Set A) : a • closure s = closure (a • s)
 lean 3 declaration is
   forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] [_inst_5 : DistribMulAction.{u1, u2} (MulOpposite.{u1} α) A (MulOpposite.monoid.{u1} α _inst_3) _inst_2] [_inst_6 : IsCentralScalar.{u1, u2} α A (SMulZeroClass.toHasSmul.{u1, u2} α A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} α A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} α A _inst_3 _inst_2 _inst_4))) (SMulZeroClass.toHasSmul.{u1, u2} (MulOpposite.{u1} α) A (AddZeroClass.toHasZero.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (DistribSMul.toSmulZeroClass.{u1, u2} (MulOpposite.{u1} α) A (AddMonoid.toAddZeroClass.{u2} A _inst_2) (DistribMulAction.toDistribSMul.{u1, u2} (MulOpposite.{u1} α) A (MulOpposite.monoid.{u1} α _inst_3) _inst_2 _inst_5)))], IsCentralScalar.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) (MulAction.toHasSmul.{u1, u2} (MulOpposite.{u1} α) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulOpposite.monoid.{u1} α _inst_3) (AddSubmonoid.pointwiseMulAction.{u1, u2} (MulOpposite.{u1} α) A _inst_2 (MulOpposite.monoid.{u1} α _inst_3) _inst_5))
 but is expected to have type
-  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : Monoid.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A _inst_3 _inst_2] [_inst_5 : DistribMulAction.{u2, u1} (MulOpposite.{u2} α) A (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) _inst_2] [_inst_6 : IsCentralScalar.{u2, u1} α A (SMulZeroClass.toSMul.{u2, u1} α A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} α A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} α A _inst_3 _inst_2 _inst_4))) (SMulZeroClass.toSMul.{u2, u1} (MulOpposite.{u2} α) A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} (MulOpposite.{u2} α) A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} (MulOpposite.{u2} α) A (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) _inst_2 _inst_5)))], IsCentralScalar.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 _inst_3 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) (AddSubmonoid.pointwiseMulAction.{u2, u1} (MulOpposite.{u2} α) A _inst_2 (MulOpposite.instMonoidMulOpposite.{u2} α _inst_3) _inst_5))
+  forall {α : Type.{u2}} {A : Type.{u1}} [_inst_2 : AddMonoid.{u1} A] [_inst_3 : Monoid.{u2} α] [_inst_4 : DistribMulAction.{u2, u1} α A _inst_3 _inst_2] [_inst_5 : DistribMulAction.{u2, u1} (MulOpposite.{u2} α) A (MulOpposite.monoid.{u2} α _inst_3) _inst_2] [_inst_6 : IsCentralScalar.{u2, u1} α A (SMulZeroClass.toSMul.{u2, u1} α A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} α A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} α A _inst_3 _inst_2 _inst_4))) (SMulZeroClass.toSMul.{u2, u1} (MulOpposite.{u2} α) A (AddMonoid.toZero.{u1} A _inst_2) (DistribSMul.toSMulZeroClass.{u2, u1} (MulOpposite.{u2} α) A (AddMonoid.toAddZeroClass.{u1} A _inst_2) (DistribMulAction.toDistribSMul.{u2, u1} (MulOpposite.{u2} α) A (MulOpposite.monoid.{u2} α _inst_3) _inst_2 _inst_5)))], IsCentralScalar.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulAction.toSMul.{u2, u1} α (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u2, u1} α A _inst_2 _inst_3 _inst_4)) (MulAction.toSMul.{u2, u1} (MulOpposite.{u2} α) (AddSubmonoid.{u1} A (AddMonoid.toAddZeroClass.{u1} A _inst_2)) (MulOpposite.monoid.{u2} α _inst_3) (AddSubmonoid.pointwiseMulAction.{u2, u1} (MulOpposite.{u2} α) A _inst_2 (MulOpposite.monoid.{u2} α _inst_3) _inst_5))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.pointwise_central_scalar AddSubmonoid.pointwise_isCentralScalarₓ'. -/
 instance pointwise_isCentralScalar [DistribMulAction αᵐᵒᵖ A] [IsCentralScalar α A] :
     IsCentralScalar α (AddSubmonoid A) :=

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

@@ -950,7 +950,9 @@ Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_indu
 @[elab_as_elim]
 protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r : R} (hr : r ∈ M * N)
     (hm : ∀ m ∈ M, ∀ n ∈ N, C (m * n)) (ha : ∀ x y, C x → C y → C (x + y)) : C r :=
-  (@mul_le _ _ _ _ ⟨C, ha, by simpa only [zero_mul] using hm _ (zero_mem _) _ (zero_mem _)⟩).2 hm hr
+  (@mul_le _ _ _ _
+        ⟨C, ha, by simpa only [MulZeroClass.zero_mul] using hm _ (zero_mem _) _ (zero_mem _)⟩).2
+    hm hr
 #align add_submonoid.mul_induction_on AddSubmonoid.mul_induction_on
 
 open Pointwise
@@ -972,8 +974,8 @@ theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S *
       intros ; apply closure_induction hb
       on_goal 1 => intros ; exact subset_closure ⟨_, _, ‹_›, ‹_›, rfl⟩
     all_goals intros ;
-      simp only [mul_zero, zero_mul, zero_mem, left_distrib, right_distrib, mul_smul_comm,
-          smul_mul_assoc] <;>
+      simp only [MulZeroClass.mul_zero, MulZeroClass.zero_mul, zero_mem, left_distrib,
+          right_distrib, mul_smul_comm, smul_mul_assoc] <;>
         solve_by_elim (config :=
           { max_depth := 4
             discharger := tactic.interactive.apply_instance }) [add_mem _ _, zero_mem _]
@@ -1001,7 +1003,7 @@ Case conversion may be inaccurate. Consider using '#align add_submonoid.mul_bot
 @[simp]
 theorem mul_bot (S : AddSubmonoid R) : S * ⊥ = ⊥ :=
   eq_bot_iff.2 <|
-    mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hn⊢ <;> rw [hn, mul_zero]
+    mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hn⊢ <;> rw [hn, MulZeroClass.mul_zero]
 #align add_submonoid.mul_bot AddSubmonoid.mul_bot
 
 /- warning: add_submonoid.bot_mul -> AddSubmonoid.bot_mul is a dubious translation:
@@ -1013,7 +1015,7 @@ Case conversion may be inaccurate. Consider using '#align add_submonoid.bot_mul
 @[simp]
 theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ :=
   eq_bot_iff.2 <|
-    mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hm⊢ <;> rw [hm, zero_mul]
+    mul_le.2 fun m hm n hn => by rw [AddSubmonoid.mem_bot] at hm⊢ <;> rw [hm, MulZeroClass.zero_mul]
 #align add_submonoid.bot_mul AddSubmonoid.bot_mul
 
 /- warning: add_submonoid.mul_le_mul -> AddSubmonoid.mul_le_mul is a dubious translation:

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

@@ -109,9 +109,9 @@ theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s :=
 
 /- warning: submonoid.closure_mul_le -> Submonoid.closure_mul_le is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (HasSup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (HasSup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (S : Set.{u1} M) (T : Set.{u1} M), 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.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) S T)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) S) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) T))
 Case conversion may be inaccurate. Consider using '#align submonoid.closure_mul_le Submonoid.closure_mul_leₓ'. -/
 @[to_additive]
 theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T :=
@@ -124,9 +124,9 @@ theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure
 
 /- warning: submonoid.sup_eq_closure -> Submonoid.sup_eq_closure is a dubious translation:
 lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (H : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (K : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (HasSup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) H K) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (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))))) H) ((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))))) K)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (H : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (K : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.completeLattice.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) H K) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toHasMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (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))))) H) ((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))))) K)))
 but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (H : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (K : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (HasSup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) H K) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) H) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) K)))
+  forall {M : Type.{u1}} [_inst_1 : Monoid.{u1} M] (H : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (K : Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)), Eq.{succ u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Sup.sup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))))) H K) (Submonoid.closure.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1) (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M (MulOneClass.toMul.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)))) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) H) (SetLike.coe.{u1, u1} (Submonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) M (Submonoid.instSetLikeSubmonoid.{u1} M (Monoid.toMulOneClass.{u1} M _inst_1)) K)))
 Case conversion may be inaccurate. Consider using '#align submonoid.sup_eq_closure Submonoid.sup_eq_closureₓ'. -/
 @[to_additive]
 theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure (H * K) :=
@@ -270,9 +270,9 @@ theorem closure_inv (s : Set G) : closure s⁻¹ = (closure s)⁻¹ :=
 
 /- warning: submonoid.inv_inf -> Submonoid.inv_inf is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (HasInf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasInf.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) S T)) (HasInf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasInf.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasInf.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) S T)) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.hasInf.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (HasInf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instHasInfSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) S T)) (HasInf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instHasInfSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instInfSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) S T)) (Inf.inf.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instInfSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
 Case conversion may be inaccurate. Consider using '#align submonoid.inv_inf Submonoid.inv_infₓ'. -/
 @[simp, to_additive]
 theorem inv_inf (S T : Submonoid G) : (S ⊓ T)⁻¹ = S⁻¹ ⊓ T⁻¹ :=
@@ -282,9 +282,9 @@ theorem inv_inf (S T : Submonoid G) : (S ⊓ T)⁻¹ = S⁻¹ ⊓ T⁻¹ :=
 
 /- warning: submonoid.inv_sup -> Submonoid.inv_sup is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (HasSup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)) (HasSup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.completeLattice.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
 but is expected to have type
-  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (HasSup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)) (HasSup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toHasSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
+  forall {G : Type.{u1}} [_inst_3 : Group.{u1} G] (S : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (T : Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))), Eq.{succ u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) S T)) (Sup.sup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (SemilatticeSup.toSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Lattice.toSemilatticeSup.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (ConditionallyCompleteLattice.toLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (CompleteLattice.toConditionallyCompleteLattice.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.instCompleteLatticeSubmonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))))))) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) S) (Inv.inv.{u1} (Submonoid.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_3)))) (Submonoid.inv.{u1} G _inst_3) T))
 Case conversion may be inaccurate. Consider using '#align submonoid.inv_sup Submonoid.inv_supₓ'. -/
 @[simp, to_additive]
 theorem inv_sup (S T : Submonoid G) : (S ⊔ T)⁻¹ = S⁻¹ ⊔ T⁻¹ :=
@@ -409,9 +409,9 @@ theorem smul_bot (a : α) : a • (⊥ : Submonoid M) = ⊥ :=
 
 /- warning: submonoid.smul_sup -> Submonoid.smul_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a (HasSup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.completeLattice.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)) (HasSup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.completeLattice.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a T))
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.completeLattice.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)) (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.completeLattice.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a S) (SMul.smul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toHasSmul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4)) a T))
 but is expected to have type
-  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a (HasSup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)) (HasSup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toHasSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a T))
+  forall {α : Type.{u1}} {M : Type.{u2}} [_inst_1 : Monoid.{u2} M] [_inst_3 : Monoid.{u1} α] [_inst_4 : MulDistribMulAction.{u1, u2} α M _inst_3 _inst_1] (a : α) (S : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (T : Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)), Eq.{succ u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) S T)) (Sup.sup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (SemilatticeSup.toSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Lattice.toSemilatticeSup.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (ConditionallyCompleteLattice.toLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.instCompleteLatticeSubmonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)))))) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (instHSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) (MulAction.toSMul.{u1, u2} α (Submonoid.{u2} M (Monoid.toMulOneClass.{u2} M _inst_1)) _inst_3 (Submonoid.pointwiseMulAction.{u1, u2} α M _inst_1 _inst_3 _inst_4))) a T))
 Case conversion may be inaccurate. Consider using '#align submonoid.smul_sup Submonoid.smul_supₓ'. -/
 theorem smul_sup (a : α) (S T : Submonoid M) : a • (S ⊔ T) = a • S ⊔ a • T :=
   map_sup _ _ _
@@ -667,9 +667,9 @@ theorem smul_bot (a : α) : a • (⊥ : AddSubmonoid A) = ⊥ :=
 
 /- warning: add_submonoid.smul_sup -> AddSubmonoid.smul_sup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a (HasSup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.completeLattice.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)) (HasSup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.completeLattice.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a T))
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.completeLattice.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)) (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.completeLattice.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a S) (SMul.smul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toHasSmul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4)) a T))
 but is expected to have type
-  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a (HasSup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)) (HasSup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toHasSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a T))
+  forall {α : Type.{u1}} {A : Type.{u2}} [_inst_2 : AddMonoid.{u2} A] [_inst_3 : Monoid.{u1} α] [_inst_4 : DistribMulAction.{u1, u2} α A _inst_3 _inst_2] (a : α) (S : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (T : AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)), Eq.{succ u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) S T)) (Sup.sup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (SemilatticeSup.toSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (Lattice.toSemilatticeSup.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (ConditionallyCompleteLattice.toLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (CompleteLattice.toConditionallyCompleteLattice.{u2} (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.instCompleteLatticeAddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)))))) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a S) (HSMul.hSMul.{u1, u2, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (instHSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) (MulAction.toSMul.{u1, u2} α (AddSubmonoid.{u2} A (AddMonoid.toAddZeroClass.{u2} A _inst_2)) _inst_3 (AddSubmonoid.pointwiseMulAction.{u1, u2} α A _inst_2 _inst_3 _inst_4))) a T))
 Case conversion may be inaccurate. Consider using '#align add_submonoid.smul_sup AddSubmonoid.smul_supₓ'. -/
 theorem smul_sup (a : α) (S T : AddSubmonoid A) : a • (S ⊔ T) = a • S ⊔ a • T :=
   map_sup _ _ _

mathlib commit https://github.com/leanprover-community/mathlib/commit/22131150f88a2d125713ffa0f4693e3355b1eb49

@@ -1152,17 +1152,25 @@ theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)
   | n + 1 => by rw [pow_succ, pow_succ, closure_pow, closure_mul_closure]
 #align add_submonoid.closure_pow AddSubmonoid.closure_pow
 
-#print AddSubmonoid.pow_eq_closure_pow_set /-
+/- warning: add_submonoid.pow_eq_closure_pow_set -> AddSubmonoid.pow_eq_closure_pow_set is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] (s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (n : Nat), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))) (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))))))) s) n))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] (s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (n : Nat), Eq.{succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n) (AddSubmonoid.closure.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (Semiring.toOne.{u1} R _inst_3) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) s) n))
+Case conversion may be inaccurate. Consider using '#align add_submonoid.pow_eq_closure_pow_set AddSubmonoid.pow_eq_closure_pow_setₓ'. -/
 theorem pow_eq_closure_pow_set (s : AddSubmonoid R) (n : ℕ) : s ^ n = closure ((s : Set R) ^ n) :=
   by rw [← closure_pow, closure_eq]
 #align add_submonoid.pow_eq_closure_pow_set AddSubmonoid.pow_eq_closure_pow_set
--/
 
-#print AddSubmonoid.pow_subset_pow /-
+/- warning: add_submonoid.pow_subset_pow -> AddSubmonoid.pow_subset_pow is a dubious translation:
+lean 3 declaration is
+  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] {s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))} {n : Nat}, HasSubset.Subset.{u1} (Set.{u1} R) (Set.hasSubset.{u1} R) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (AddMonoidWithOne.toOne.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))) (Distrib.toHasMul.{u1} R (NonUnitalNonAssocSemiring.toDistrib.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))))))) s) n) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (HasLiftT.mk.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (CoeTCₓ.coe.{succ u1, succ u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (Set.{u1} R) (SetLike.Set.hasCoeT.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.setLike.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n))
+but is expected to have type
+  forall {R : Type.{u1}} [_inst_3 : Semiring.{u1} R] {s : AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))} {n : Nat}, HasSubset.Subset.{u1} (Set.{u1} R) (Set.instHasSubsetSet.{u1} R) (HPow.hPow.{u1, 0, u1} (Set.{u1} R) Nat (Set.{u1} R) (instHPow.{u1, 0} (Set.{u1} R) Nat (Set.NPow.{u1} R (Semiring.toOne.{u1} R _inst_3) (NonUnitalNonAssocSemiring.toMul.{u1} R (NonAssocSemiring.toNonUnitalNonAssocSemiring.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3))))) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) s) n) (SetLike.coe.{u1, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) R (AddSubmonoid.instSetLikeAddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (HPow.hPow.{u1, 0, u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (instHPow.{u1, 0} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) Nat (Monoid.Pow.{u1} (AddSubmonoid.{u1} R (AddMonoid.toAddZeroClass.{u1} R (AddMonoidWithOne.toAddMonoid.{u1} R (AddCommMonoidWithOne.toAddMonoidWithOne.{u1} R (NonAssocSemiring.toAddCommMonoidWithOne.{u1} R (Semiring.toNonAssocSemiring.{u1} R _inst_3)))))) (AddSubmonoid.monoid.{u1} R _inst_3))) s n))
+Case conversion may be inaccurate. Consider using '#align add_submonoid.pow_subset_pow AddSubmonoid.pow_subset_powₓ'. -/
 theorem pow_subset_pow {s : AddSubmonoid R} {n : ℕ} : (↑s : Set R) ^ n ⊆ ↑(s ^ n) :=
   (pow_eq_closure_pow_set s n).symm ▸ subset_closure
 #align add_submonoid.pow_subset_pow AddSubmonoid.pow_subset_pow
--/
 
 end Semiring
 
@@ -1172,7 +1180,12 @@ namespace Set.IsPwo
 
 variable [OrderedCancelCommMonoid α] {s : Set α}
 
-#print Set.IsPwo.submonoid_closure /-
+/- warning: set.is_pwo.submonoid_closure -> Set.IsPwo.submonoid_closure is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_3 : OrderedCancelCommMonoid.{u1} α] {s : Set.{u1} α}, (forall (x : α), (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) x)) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) s) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (HasLiftT.mk.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Set.{u1} α) (SetLike.Set.hasCoeT.{u1, u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) α (Submonoid.setLike.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))))))) (Submonoid.closure.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))) s)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_3 : OrderedCancelCommMonoid.{u1} α] {s : Set.{u1} α}, (forall (x : α), (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) x s) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (RightCancelMonoid.toOne.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) x)) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) s) -> (Set.IsPwo.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCancelCommMonoid.toPartialOrder.{u1} α _inst_3)) (SetLike.coe.{u1, u1} (Submonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) α (Submonoid.instSetLikeSubmonoid.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3)))))) (Submonoid.closure.{u1} α (Monoid.toMulOneClass.{u1} α (RightCancelMonoid.toMonoid.{u1} α (CancelMonoid.toRightCancelMonoid.{u1} α (CancelCommMonoid.toCancelMonoid.{u1} α (OrderedCancelCommMonoid.toCancelCommMonoid.{u1} α _inst_3))))) s)))
+Case conversion may be inaccurate. Consider using '#align set.is_pwo.submonoid_closure Set.IsPwo.submonoid_closureₓ'. -/
 @[to_additive]
 theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPwo) :
     IsPwo (Submonoid.closure s : Set α) :=
@@ -1182,7 +1195,6 @@ theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPwo)
   exact fun l1 hl1 l2 hl2 h12 => h12.prod_le_prod' fun x hx => hpos x <| hl2 x hx
 #align set.is_pwo.submonoid_closure Set.IsPwo.submonoid_closure
 #align set.is_pwo.add_submonoid_closure Set.IsPwo.addSubmonoid_closure
--/
 
 end Set.IsPwo
 

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

Take the content of

• some of Algebra.BigOperators.List.Basic
• some of Algebra.BigOperators.List.Lemmas
• some of Algebra.BigOperators.Multiset.Basic
• some of Algebra.BigOperators.Multiset.Lemmas
• Algebra.BigOperators.Multiset.Order
• Algebra.BigOperators.Order

and sort it into six files:

• Algebra.Order.BigOperators.Group.List. I credit Yakov for https://github.com/leanprover-community/mathlib/pull/8543.
• Algebra.Order.BigOperators.Group.Multiset. Copyright inherited from Algebra.BigOperators.Multiset.Order.
• Algebra.Order.BigOperators.Group.Finset. Copyright inherited from Algebra.BigOperators.Order.
• Algebra.Order.BigOperators.Ring.List. I credit Stuart for https://github.com/leanprover-community/mathlib/pull/10184.
• Algebra.Order.BigOperators.Ring.Multiset. I credit Ruben for https://github.com/leanprover-community/mathlib/pull/8787.
• Algebra.Order.BigOperators.Ring.Finset. I credit Floris for https://github.com/leanprover-community/mathlib/pull/1294.

Here are the design decisions at play:

• Pure algebra and big operators algebra shouldn't import (algebraic) order theory. This PR makes that better, but not perfect because we still import Data.Nat.Order.Basic in a few List files.
• It's Algebra.Order.BigOperators instead of Algebra.BigOperators.Order because algebraic order theory is more of a theory than big operators algebra. Another reason is that algebraic order theory is the only way to mix pure order and pure algebra, while there are more ways to mix pure finiteness and pure algebra than just big operators.
• There are separate files for group/monoid lemmas vs ring lemmas. Groups/monoids are the natural setup for big operators, so their lemmas shouldn't be mixed with ring lemmas that involves both addition and multiplication. As a result, everything under Algebra.Order.BigOperators.Group should be additivisable (except a few Nat- or Int-specific lemmas). In contrast, things under Algebra.Order.BigOperators.Ring are more prone to having heavy imports.
• Lemmas are separated according to List vs Multiset vs Finset. This is not strictly necessary, and can be relaxed in cases where there aren't that many lemmas to be had. As an example, I could split out the AbsoluteValue lemmas from Algebra.Order.BigOperators.Ring.Finset to a file Algebra.Order.BigOperators.Ring.AbsoluteValue and it could stay this way until too many lemmas are in this file (or a split is needed for import reasons), in which case we would need files Algebra.Order.BigOperators.Ring.AbsoluteValue.Finset, Algebra.Order.BigOperators.Ring.AbsoluteValue.Multiset, etc...
• Finsupp big operator and finprod/finsum order lemmas also belong in Algebra.Order.BigOperators. I haven't done so in this PR because the diff is big enough like that.

@@ -3,6 +3,7 @@ Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 -/
+import Mathlib.Algebra.Order.BigOperators.Group.List
 import Mathlib.Data.Set.Pointwise.SMul
 import Mathlib.GroupTheory.Submonoid.Membership
 import Mathlib.Order.WellFoundedSet

Everywhere we have a smul_mem_pointwise_smul lemma, I've added this result.

@@ -239,6 +239,9 @@ theorem smul_mem_pointwise_smul (m : M) (a : α) (S : Submonoid M) : m ∈ S →
   (Set.smul_mem_smul_set : _ → _ ∈ a • (S : Set M))
 #align submonoid.smul_mem_pointwise_smul Submonoid.smul_mem_pointwise_smul
 
+instance : CovariantClass α (Submonoid M) HSMul.hSMul LE.le :=
+  ⟨fun _ _ => image_subset _⟩
+
 theorem mem_smul_pointwise_iff_exists (m : M) (a : α) (S : Submonoid M) :
     m ∈ a • S ↔ ∃ s : M, s ∈ S ∧ a • s = m :=
   (Set.mem_smul_set : m ∈ a • (S : Set M) ↔ _)

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

@@ -46,7 +46,6 @@ on `Set`s.
 open Set Pointwise
 
 variable {α : Type*} {G : Type*} {M : Type*} {R : Type*} {A : Type*}
-
 variable [Monoid M] [AddMonoid A]
 
 /-! Some lemmas about pointwise multiplication and submonoids. Ideally we put these in

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

@@ -546,7 +546,7 @@ protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r :
 #align add_submonoid.mul_induction_on AddSubmonoid.mul_induction_on
 
 -- this proof is copied directly from `Submodule.span_mul_span`
--- porting note: proof rewritten
+-- Porting note: proof rewritten
 theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S * T) := by
   apply le_antisymm
   · refine mul_le.2 fun a ha b hb => ?_

Rename Set.IsPwo → Set.IsPWO and Set.IsWf → Set.IsWF.

@@ -689,17 +689,17 @@ end Semiring
 
 end AddSubmonoid
 
-namespace Set.IsPwo
+namespace Set.IsPWO
 
 variable [OrderedCancelCommMonoid α] {s : Set α}
 
 @[to_additive]
-theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPwo) :
-    IsPwo (Submonoid.closure s : Set α) := by
+theorem submonoid_closure (hpos : ∀ x : α, x ∈ s → 1 ≤ x) (h : s.IsPWO) :
+    IsPWO (Submonoid.closure s : Set α) := by
   rw [Submonoid.closure_eq_image_prod]
   refine' (h.partiallyWellOrderedOn_sublistForall₂ (· ≤ ·)).image_of_monotone_on _
   exact fun l1 _ l2 hl2 h12 => h12.prod_le_prod' fun x hx => hpos x <| hl2 x hx
-#align set.is_pwo.submonoid_closure Set.IsPwo.submonoid_closure
-#align set.is_pwo.add_submonoid_closure Set.IsPwo.addSubmonoid_closure
+#align set.is_pwo.submonoid_closure Set.IsPWO.submonoid_closure
+#align set.is_pwo.add_submonoid_closure Set.IsPWO.addSubmonoid_closure
 
-end Set.IsPwo
+end Set.IsPWO

• Redefine Set.image2 to use ∃ a ∈ s, ∃ b ∈ t, f a b = c instead of ∃ a b, a ∈ s ∧ b ∈ t ∧ f a b = c.
• Redefine Set.seq as Set.image2. The new definition is equal to the old one but rw [Set.seq] gives a different result.
• Redefine Filter.map₂ to use ∃ u ∈ f, ∃ v ∈ g, image2 m u v ⊆ s instead of ∃ u v, u ∈ f ∧ v ∈ g ∧ ...
• Update lemmas like Set.mem_image2, Finset.mem_image₂, Set.mem_mul, Finset.mem_div etc

The two reasons to make the change are:

• ∃ a ∈ s, ∃ b ∈ t, _ is a simp-normal form, and
• it looks a bit nicer.

@@ -71,15 +71,15 @@ theorem mul_subset_closure (hs : s ⊆ u) (ht : t ⊆ u) : s * t ⊆ Submonoid.c
 @[to_additive]
 theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s := by
   ext x
-  refine' ⟨_, fun h => ⟨x, 1, h, s.one_mem, mul_one x⟩⟩
-  rintro ⟨a, b, ha, hb, rfl⟩
+  refine' ⟨_, fun h => ⟨x, h, 1, s.one_mem, mul_one x⟩⟩
+  rintro ⟨a, ha, b, hb, rfl⟩
   exact s.mul_mem ha hb
 #align submonoid.coe_mul_self_eq Submonoid.coe_mul_self_eq
 #align add_submonoid.coe_add_self_eq AddSubmonoid.coe_add_self_eq
 
 @[to_additive]
 theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T :=
-  sInf_le fun _x ⟨_s, _t, hs, ht, hx⟩ => hx ▸
+  sInf_le fun _x ⟨_s, hs, _t, ht, hx⟩ => hx ▸
     (closure S ⊔ closure T).mul_mem (SetLike.le_def.mp le_sup_left <| subset_closure hs)
       (SetLike.le_def.mp le_sup_right <| subset_closure ht)
 #align submonoid.closure_mul_le Submonoid.closure_mul_le
@@ -88,8 +88,8 @@ theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure
 @[to_additive]
 theorem sup_eq_closure_mul (H K : Submonoid M) : H ⊔ K = closure ((H : Set M) * (K : Set M)) :=
   le_antisymm
-    (sup_le (fun h hh => subset_closure ⟨h, 1, hh, K.one_mem, mul_one h⟩) fun k hk =>
-      subset_closure ⟨1, k, H.one_mem, hk, one_mul k⟩)
+    (sup_le (fun h hh => subset_closure ⟨h, hh, 1, K.one_mem, mul_one h⟩) fun k hk =>
+      subset_closure ⟨1, H.one_mem, k, hk, one_mul k⟩)
     ((closure_mul_le _ _).trans <| by rw [closure_eq, closure_eq])
 #align submonoid.sup_eq_closure Submonoid.sup_eq_closure_mul
 #align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure_add
@@ -557,7 +557,7 @@ theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S *
     change a' * b' ∈ closure (S * T)
     exact subset_closure (Set.mul_mem_mul ha' hb')
   · rw [closure_le]
-    rintro _ ⟨a, b, ha, hb, rfl⟩
+    rintro _ ⟨a, ha, b, hb, rfl⟩
     exact mul_mem_mul (subset_closure ha) (subset_closure hb)
 #align add_submonoid.closure_mul_closure AddSubmonoid.closure_mul_closure
 

Use Set.image2_subset_iff, Set.mul_subset_iff, and Set.add_subset_iff instead of rintros.

Also protect some *.image2 lemmas.

@@ -57,9 +57,8 @@ namespace Submonoid
 variable {s t u : Set M}
 
 @[to_additive]
-theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S := by
-  rintro _ ⟨p, q, hp, hq, rfl⟩
-  exact Submonoid.mul_mem _ (hs hp) (ht hq)
+theorem mul_subset {S : Submonoid M} (hs : s ⊆ S) (ht : t ⊆ S) : s * t ⊆ S :=
+  mul_subset_iff.2 fun _x hx _y hy ↦ mul_mem (hs hx) (ht hy)
 #align submonoid.mul_subset Submonoid.mul_subset
 #align add_submonoid.add_subset AddSubmonoid.add_subset
 
@@ -593,9 +592,8 @@ theorem mul_le_mul_right {M N P : AddSubmonoid R} (h : N ≤ P) : M * N ≤ M *
 #align add_submonoid.mul_le_mul_right AddSubmonoid.mul_le_mul_right
 
 theorem mul_subset_mul {M N : AddSubmonoid R} :
-    (↑M : Set R) * (↑N : Set R) ⊆ (↑(M * N) : Set R) := by
-  rintro _ ⟨i, j, hi, hj, rfl⟩
-  exact mul_mem_mul hi hj
+    (↑M : Set R) * (↑N : Set R) ⊆ (↑(M * N) : Set R) :=
+  mul_subset_iff.2 fun _i hi _j hj ↦ mul_mem_mul hi hj
 #align add_submonoid.mul_subset_mul AddSubmonoid.mul_subset_mul
 
 end NonUnitalNonAssocSemiring

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

@@ -678,8 +678,9 @@ theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)
   | n + 1 => by rw [pow_succ, pow_succ, closure_pow s n, closure_mul_closure]
 #align add_submonoid.closure_pow AddSubmonoid.closure_pow
 
-theorem pow_eq_closure_pow_set (s : AddSubmonoid R) (n : ℕ) : s ^ n = closure ((s : Set R) ^ n) :=
-  by rw [← closure_pow, closure_eq]
+theorem pow_eq_closure_pow_set (s : AddSubmonoid R) (n : ℕ) :
+    s ^ n = closure ((s : Set R) ^ n) := by
+  rw [← closure_pow, closure_eq]
 #align add_submonoid.pow_eq_closure_pow_set AddSubmonoid.pow_eq_closure_pow_set
 
 theorem pow_subset_pow {s : AddSubmonoid R} {n : ℕ} : (↑s : Set R) ^ n ⊆ ↑(s ^ n) :=

@@ -87,13 +87,13 @@ theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure
 #align add_submonoid.closure_add_le AddSubmonoid.closure_add_le
 
 @[to_additive]
-theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure ((H : Set M) * (K : Set M)) :=
+theorem sup_eq_closure_mul (H K : Submonoid M) : H ⊔ K = closure ((H : Set M) * (K : Set M)) :=
   le_antisymm
     (sup_le (fun h hh => subset_closure ⟨h, 1, hh, K.one_mem, mul_one h⟩) fun k hk =>
       subset_closure ⟨1, k, H.one_mem, hk, one_mul k⟩)
     ((closure_mul_le _ _).trans <| by rw [closure_eq, closure_eq])
-#align submonoid.sup_eq_closure Submonoid.sup_eq_closure
-#align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure
+#align submonoid.sup_eq_closure Submonoid.sup_eq_closure_mul
+#align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure_add
 
 @[to_additive]
 theorem pow_smul_mem_closure_smul {N : Type*} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]

This removes redundant field values of the form add := add for smaller terms and less unfolding during unification.

A list of all files containing a structure instance of the form { a1, ... with x1 := val, ... } where some xi is a field of some aj was generated by modifying the structure instance elaboration algorithm to print such overlaps to stdout in a custom toolchain.

Using that toolchain, I went through each file on the list and attempted to remove algebraic fields that overlapped and were redundant, eg add := add and not toFun (though some other ones did creep in). If things broke (which was the case in a couple of cases), I did not push further and reverted.

It is possible that pushing harder and trying to remove all redundant overlaps will yield further improvements.

@@ -609,7 +609,6 @@ variable [NonUnitalNonAssocRing R]
 This is available as an instance in the `Pointwise` locale. -/
 protected def hasDistribNeg : HasDistribNeg (AddSubmonoid R) :=
   { AddSubmonoid.involutiveNeg with
-    neg := Neg.neg
     neg_mul := fun x y => by
       refine'
           le_antisymm (mul_le.2 fun m hm n hn => _)
@@ -671,9 +670,7 @@ variable [Semiring R]
 
 /-- Monoid structure on additive submonoids of a semiring. -/
 protected def monoid : Monoid (AddSubmonoid R) :=
-  { AddSubmonoid.semigroup, AddSubmonoid.mulOneClass with
-    one := 1
-    mul := (· * ·) }
+  { AddSubmonoid.semigroup, AddSubmonoid.mulOneClass with }
 scoped[Pointwise] attribute [instance] AddSubmonoid.monoid
 
 theorem closure_pow (s : Set R) : ∀ n : ℕ, closure s ^ n = closure (s ^ n)

Just the one character pointwise to Pointwise in the doc-module.

@@ -23,7 +23,7 @@ and the actions
 
 which matches the action of `Set.mulActionSet`.
 
-These are all available in the `pointwise` locale.
+These are all available in the `Pointwise` locale.
 
 Additionally, it provides various degrees of monoid structure:
 * `AddSubmonoid.one`

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

This has nice performance benefits.

@@ -45,7 +45,7 @@ on `Set`s.
 
 open Set Pointwise
 
-variable {α : Type _} {G : Type _} {M : Type _} {R : Type _} {A : Type _}
+variable {α : Type*} {G : Type*} {M : Type*} {R : Type*} {A : Type*}
 
 variable [Monoid M] [AddMonoid A]
 
@@ -96,7 +96,7 @@ theorem sup_eq_closure (H K : Submonoid M) : H ⊔ K = closure ((H : Set M) * (K
 #align add_submonoid.sup_eq_closure AddSubmonoid.sup_eq_closure
 
 @[to_additive]
-theorem pow_smul_mem_closure_smul {N : Type _} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]
+theorem pow_smul_mem_closure_smul {N : Type*} [CommMonoid N] [MulAction M N] [IsScalarTower M N N]
     (r : M) (s : Set N) {x : N} (hx : x ∈ closure s) : ∃ n : ℕ, r ^ n • x ∈ closure (r • s) := by
   refine' @closure_induction N _ s (fun x : N => ∃ n : ℕ, r ^ n • x ∈ closure (r • s)) _ hx _ _ _
   · intro x hx
@@ -197,13 +197,13 @@ theorem inv_top : (⊤ : Submonoid G)⁻¹ = ⊤ :=
 #align add_submonoid.neg_top AddSubmonoid.neg_top
 
 @[to_additive (attr := simp)]
-theorem inv_iInf {ι : Sort _} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ :=
+theorem inv_iInf {ι : Sort*} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ :=
   (invOrderIso : Submonoid G ≃o Submonoid G).map_iInf _
 #align submonoid.inv_infi Submonoid.inv_iInf
 #align add_submonoid.neg_infi AddSubmonoid.neg_iInf
 
 @[to_additive (attr := simp)]
-theorem inv_iSup {ι : Sort _} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
+theorem inv_iSup {ι : Sort*} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
   (invOrderIso : Submonoid G ≃o Submonoid G).map_iSup _
 #align submonoid.inv_supr Submonoid.inv_iSup
 #align add_submonoid.neg_supr AddSubmonoid.neg_iSup
@@ -338,7 +338,7 @@ theorem le_pointwise_smul_iff₀ {a : α} (ha : a ≠ 0) {S T : Submonoid M} : S
 end GroupWithZero
 
 @[to_additive]
-theorem mem_closure_inv {G : Type _} [Group G] (S : Set G) (x : G) :
+theorem mem_closure_inv {G : Type*} [Group G] (S : Set G) (x : G) :
     x ∈ Submonoid.closure S⁻¹ ↔ x⁻¹ ∈ Submonoid.closure S := by rw [closure_inv, mem_inv]
 #align submonoid.mem_closure_inv Submonoid.mem_closure_inv
 #align add_submonoid.mem_closure_neg AddSubmonoid.mem_closure_neg

• depends on: #5966

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

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Eric Wieser. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
-
-! This file was ported from Lean 3 source module group_theory.submonoid.pointwise
-! leanprover-community/mathlib commit 2bbc7e3884ba234309d2a43b19144105a753292e
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Set.Pointwise.SMul
 import Mathlib.GroupTheory.Submonoid.Membership
 import Mathlib.Order.WellFoundedSet
 
+#align_import group_theory.submonoid.pointwise from "leanprover-community/mathlib"@"2bbc7e3884ba234309d2a43b19144105a753292e"
+
 /-! # Pointwise instances on `Submonoid`s and `AddSubmonoid`s
 
 This file provides:

@@ -530,7 +530,7 @@ variable [NonUnitalNonAssocSemiring R]
 /-- Multiplication of additive submonoids of a semiring R. The additive submonoid `S * T` is the
 smallest R-submodule of `R` containing the elements `s * t` for `s ∈ S` and `t ∈ T`. -/
 protected def mul : Mul (AddSubmonoid R) :=
-  ⟨fun M N => ⨆ s : M, N.map <| AddMonoidHom.mul s.1⟩
+  ⟨fun M N => ⨆ s : M, N.map (AddMonoidHom.mul s.1)⟩
 scoped[Pointwise] attribute [instance] AddSubmonoid.mul
 
 theorem mul_mem_mul {M N : AddSubmonoid R} {m n : R} (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N :=

Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Mario Carneiro <di.gama@gmail.com> Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com> Co-authored-by: Jeremy Tan Jie Rui <reddeloostw@gmail.com> Co-authored-by: Alex J Best <alex.j.best@gmail.com>

@@ -512,7 +512,8 @@ theorem mem_one {x : R} : x ∈ (1 : AddSubmonoid R) ↔ ∃ n : ℕ, ↑n = x :
 
 theorem one_eq_closure : (1 : AddSubmonoid R) = closure {1} := by
   rw [closure_singleton_eq, one_eq_mrange]
-  congr 1 with n
+  congr 1
+  ext
   simp
 #align add_submonoid.one_eq_closure AddSubmonoid.one_eq_closure
 

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>

@@ -83,7 +83,7 @@ theorem coe_mul_self_eq (s : Submonoid M) : (s : Set M) * s = s := by
 
 @[to_additive]
 theorem closure_mul_le (S T : Set M) : closure (S * T) ≤ closure S ⊔ closure T :=
-  infₛ_le fun _x ⟨_s, _t, hs, ht, hx⟩ => hx ▸
+  sInf_le fun _x ⟨_s, _t, hs, ht, hx⟩ => hx ▸
     (closure S ⊔ closure T).mul_mem (SetLike.le_def.mp le_sup_left <| subset_closure hs)
       (SetLike.le_def.mp le_sup_right <| subset_closure ht)
 #align submonoid.closure_mul_le Submonoid.closure_mul_le
@@ -200,16 +200,16 @@ theorem inv_top : (⊤ : Submonoid G)⁻¹ = ⊤ :=
 #align add_submonoid.neg_top AddSubmonoid.neg_top
 
 @[to_additive (attr := simp)]
-theorem inv_infᵢ {ι : Sort _} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ :=
-  (invOrderIso : Submonoid G ≃o Submonoid G).map_infᵢ _
-#align submonoid.inv_infi Submonoid.inv_infᵢ
-#align add_submonoid.neg_infi AddSubmonoid.neg_infᵢ
+theorem inv_iInf {ι : Sort _} (S : ι → Submonoid G) : (⨅ i, S i)⁻¹ = ⨅ i, (S i)⁻¹ :=
+  (invOrderIso : Submonoid G ≃o Submonoid G).map_iInf _
+#align submonoid.inv_infi Submonoid.inv_iInf
+#align add_submonoid.neg_infi AddSubmonoid.neg_iInf
 
 @[to_additive (attr := simp)]
-theorem inv_supᵢ {ι : Sort _} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
-  (invOrderIso : Submonoid G ≃o Submonoid G).map_supᵢ _
-#align submonoid.inv_supr Submonoid.inv_supᵢ
-#align add_submonoid.neg_supr AddSubmonoid.neg_supᵢ
+theorem inv_iSup {ι : Sort _} (S : ι → Submonoid G) : (⨆ i, S i)⁻¹ = ⨆ i, (S i)⁻¹ :=
+  (invOrderIso : Submonoid G ≃o Submonoid G).map_iSup _
+#align submonoid.inv_supr Submonoid.inv_iSup
+#align add_submonoid.neg_supr AddSubmonoid.neg_iSup
 
 end Submonoid
 
@@ -533,12 +533,12 @@ protected def mul : Mul (AddSubmonoid R) :=
 scoped[Pointwise] attribute [instance] AddSubmonoid.mul
 
 theorem mul_mem_mul {M N : AddSubmonoid R} {m n : R} (hm : m ∈ M) (hn : n ∈ N) : m * n ∈ M * N :=
-  (le_supᵢ _ ⟨m, hm⟩ : _ ≤ M * N) ⟨n, hn, by rfl⟩
+  (le_iSup _ ⟨m, hm⟩ : _ ≤ M * N) ⟨n, hn, by rfl⟩
 #align add_submonoid.mul_mem_mul AddSubmonoid.mul_mem_mul
 
 theorem mul_le {M N P : AddSubmonoid R} : M * N ≤ P ↔ ∀ m ∈ M, ∀ n ∈ N, m * n ∈ P :=
   ⟨fun H _m hm _n hn => H <| mul_mem_mul hm hn, fun H =>
-    supᵢ_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
+    iSup_le fun ⟨m, hm⟩ => map_le_iff_le_comap.2 fun n hn => H m hm n hn⟩
 #align add_submonoid.mul_le AddSubmonoid.mul_le
 
 @[elab_as_elim]

@@ -553,7 +553,7 @@ protected theorem mul_induction_on {M N : AddSubmonoid R} {C : R → Prop} {r :
 theorem closure_mul_closure (S T : Set R) : closure S * closure T = closure (S * T) := by
   apply le_antisymm
   · refine mul_le.2 fun a ha b hb => ?_
-    rw [← AddMonoidHom.mul_right_apply, ← AddSubmonoid.mem_comap]
+    rw [← AddMonoidHom.mulRight_apply, ← AddSubmonoid.mem_comap]
     refine (closure_le.2 fun a' ha' => ?_) ha
     change b ∈ (closure (S * T)).comap (AddMonoidHom.mulLeft a')
     refine (closure_le.2 fun b' hb' => ?_) hb

Restore most of the mono attribute now that #1740 is merged.

I think I got all of the monos.

@@ -581,7 +581,7 @@ theorem bot_mul (S : AddSubmonoid R) : ⊥ * S = ⊥ :=
     rw [AddSubmonoid.mem_bot] at hm ⊢; rw [hm, zero_mul]
 #align add_submonoid.bot_mul AddSubmonoid.bot_mul
 
--- porting note: todo: restore @[mono]
+@[mono]
 theorem mul_le_mul {M N P Q : AddSubmonoid R} (hmp : M ≤ P) (hnq : N ≤ Q) : M * N ≤ P * Q :=
   mul_le.2 fun _m hm _n hn => mul_mem_mul (hmp hm) (hnq hn)
 #align add_submonoid.mul_le_mul AddSubmonoid.mul_le_mul

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Eric Wieser
 
 ! This file was ported from Lean 3 source module group_theory.submonoid.pointwise
-! leanprover-community/mathlib commit bcfa726826abd57587355b4b5b7e78ad6527b7e4
+! leanprover-community/mathlib commit 2bbc7e3884ba234309d2a43b19144105a753292e
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -34,7 +34,7 @@ Additionally, it provides various degrees of monoid structure:
 * `AddSubmonoid.mulOneClass`
 * `AddSubmonoid.semigroup`
 * `AddSubmonoid.monoid`
-which is available globally to match the monoid structure implied by `Submodule.semiring`.
+which is available globally to match the monoid structure implied by `Submodule.idemSemiring`.
 
 ## Implementation notes
 

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

@@ -158,7 +158,7 @@ theorem inv_le (S T : Submonoid G) : S⁻¹ ≤ T ↔ S ≤ T⁻¹ :=
 #align add_submonoid.neg_le AddSubmonoid.neg_le
 
 /-- Pointwise inversion of submonoids as an order isomorphism. -/
-@[to_additive (attr := simps) " Pointwise negation of additive submonoids as an order isomorphism "]
+@[to_additive (attr := simps!) "Pointwise negation of additive submonoids as an order isomorphism"]
 def invOrderIso : Submonoid G ≃o Submonoid G where
   toEquiv := Equiv.inv _
   map_rel_iff' := inv_le_inv _ _

@@ -158,7 +158,7 @@ theorem inv_le (S T : Submonoid G) : S⁻¹ ≤ T ↔ S ≤ T⁻¹ :=
 #align add_submonoid.neg_le AddSubmonoid.neg_le
 
 /-- Pointwise inversion of submonoids as an order isomorphism. -/
-@[to_additive " Pointwise negation of additive submonoids as an order isomorphism ", simps]
+@[to_additive (attr := simps) " Pointwise negation of additive submonoids as an order isomorphism "]
 def invOrderIso : Submonoid G ≃o Submonoid G where
   toEquiv := Equiv.inv _
   map_rel_iff' := inv_le_inv _ _

@@ -24,21 +24,21 @@ and the actions
 * `Submonoid.pointwiseMulAction`
 * `AddSubmonoid.pointwiseMulAction`
 
-which matches the action of `mul_action_set`.
+which matches the action of `Set.mulActionSet`.
 
 These are all available in the `pointwise` locale.
 
 Additionally, it provides various degrees of monoid structure:
-* `add_submonoid.has_one`
-* `add_submonoid.has_mul`
-* `add_submonoid.mul_one_class`
-* `add_submonoid.semigroup`
-* `add_submonoid.monoid`
-which is available globally to match the monoid structure implied by `submodule.semiring`.
+* `AddSubmonoid.one`
+* `AddSubmonoid.mul`
+* `AddSubmonoid.mulOneClass`
+* `AddSubmonoid.semigroup`
+* `AddSubmonoid.monoid`
+which is available globally to match the monoid structure implied by `Submodule.semiring`.
 
 ## Implementation notes
 
-Most of the lemmas in this file are direct copies of lemmas from `algebra/pointwise.lean`.
+Most of the lemmas in this file are direct copies of lemmas from `Algebra/Pointwise.lean`.
 While the statements of these lemmas are defeq, we repeat them here due to them not being
 syntactically equal. Before adding new lemmas here, consider if they would also apply to the action
 on `Set`s.
@@ -116,8 +116,8 @@ variable [Group G]
 
 /-- The submonoid with every element inverted. -/
 @[to_additive " The additive submonoid with every element negated. "]
-protected def inv : Inv (Submonoid G)
-    where inv S :=
+protected def inv : Inv (Submonoid G) where
+  inv S :=
     { carrier := (S : Set G)⁻¹
       mul_mem' := fun ha hb => by rw [mem_inv, mul_inv_rev]; exact mul_mem hb ha
       one_mem' := mem_inv.2 <| by rw [inv_one]; exact S.one_mem' }
@@ -262,12 +262,12 @@ theorem smul_closure (a : α) (s : Set M) : a • closure s = closure (a • s)
   MonoidHom.map_mclosure _ _
 #align submonoid.smul_closure Submonoid.smul_closure
 
-lemma pointwise_central_scalar [MulDistribMulAction αᵐᵒᵖ M] [IsCentralScalar α M] :
+lemma pointwise_isCentralScalar [MulDistribMulAction αᵐᵒᵖ M] [IsCentralScalar α M] :
     IsCentralScalar α (Submonoid M) :=
   ⟨fun _ S => (congr_arg fun f : Monoid.End M => S.map f) <| MonoidHom.ext <| op_smul_eq_smul _⟩
-#align submonoid.pointwise_central_scalar Submonoid.pointwise_central_scalar
+#align submonoid.pointwise_central_scalar Submonoid.pointwise_isCentralScalar
 
-scoped[Pointwise] attribute [instance] Submonoid.pointwise_central_scalar
+scoped[Pointwise] attribute [instance] Submonoid.pointwise_isCentralScalar
 
 end Monoid
 
@@ -357,8 +357,7 @@ variable [Monoid α] [DistribMulAction α A]
 /-- The action on an additive submonoid corresponding to applying the action to every element.
 
 This is available as an instance in the `Pointwise` locale. -/
-protected def pointwiseMulAction : MulAction α (AddSubmonoid A)
-    where
+protected def pointwiseMulAction : MulAction α (AddSubmonoid A) where
   smul a S := S.map (DistribMulAction.toAddMonoidEnd _ A a)
   one_smul S :=
     (congr_arg (fun f : AddMonoid.End A => S.map f) (MonoidHom.map_one _)).trans S.map_id
@@ -397,13 +396,13 @@ theorem smul_closure (a : α) (s : Set A) : a • closure s = closure (a • s)
   AddMonoidHom.map_mclosure _ _
 #align add_submonoid.smul_closure AddSubmonoid.smul_closure
 
-lemma pointwise_central_scalar [DistribMulAction αᵐᵒᵖ A] [IsCentralScalar α A] :
+lemma pointwise_isCentralScalar [DistribMulAction αᵐᵒᵖ A] [IsCentralScalar α A] :
     IsCentralScalar α (AddSubmonoid A) :=
   ⟨fun _ S =>
     (congr_arg fun f : AddMonoid.End A => S.map f) <| AddMonoidHom.ext <| op_smul_eq_smul _⟩
-#align add_submonoid.pointwise_central_scalar AddSubmonoid.pointwise_central_scalar
+#align add_submonoid.pointwise_central_scalar AddSubmonoid.pointwise_isCentralScalar
 
-scoped[Pointwise] attribute [instance] AddSubmonoid.pointwise_central_scalar
+scoped[Pointwise] attribute [instance] AddSubmonoid.pointwise_isCentralScalar
 
 end Monoid
 
@@ -502,9 +501,9 @@ theorem one_eq_mrange : (1 : AddSubmonoid R) = AddMonoidHom.mrange (Nat.castAddM
   rfl
 #align add_submonoid.one_eq_mrange AddSubmonoid.one_eq_mrange
 
-theorem nat_cast_mem_one (n : ℕ) : (n : R) ∈ (1 : AddSubmonoid R) :=
+theorem natCast_mem_one (n : ℕ) : (n : R) ∈ (1 : AddSubmonoid R) :=
   ⟨_, rfl⟩
-#align add_submonoid.nat_cast_mem_one AddSubmonoid.nat_cast_mem_one
+#align add_submonoid.nat_cast_mem_one AddSubmonoid.natCast_mem_one
 
 @[simp]
 theorem mem_one {x : R} : x ∈ (1 : AddSubmonoid R) ↔ ∃ n : ℕ, ↑n = x :=

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