algebra.bounds ⟷ Mathlib.Algebra.Bounds

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

@@ -3,11 +3,11 @@ Copyright (c) 2021 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
 -/
-import Mathbin.Algebra.Order.Group.OrderIso
-import Mathbin.Algebra.Order.Monoid.OrderDual
-import Mathbin.Data.Set.Pointwise.Basic
-import Mathbin.Order.Bounds.OrderIso
-import Mathbin.Order.ConditionallyCompleteLattice.Basic
+import Algebra.Order.Group.OrderIso
+import Algebra.Order.Monoid.OrderDual
+import Data.Set.Pointwise.Basic
+import Order.Bounds.OrderIso
+import Order.ConditionallyCompleteLattice.Basic
 
 #align_import algebra.bounds from "leanprover-community/mathlib"@"be24ec5de6701447e5df5ca75400ffee19d65659"
 

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module algebra.bounds
-! leanprover-community/mathlib commit be24ec5de6701447e5df5ca75400ffee19d65659
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.Order.Group.OrderIso
 import Mathbin.Algebra.Order.Monoid.OrderDual
@@ -14,6 +9,8 @@ import Mathbin.Data.Set.Pointwise.Basic
 import Mathbin.Order.Bounds.OrderIso
 import Mathbin.Order.ConditionallyCompleteLattice.Basic
 
+#align_import algebra.bounds from "leanprover-community/mathlib"@"be24ec5de6701447e5df5ca75400ffee19d65659"
+
 /-!
 # Upper/lower bounds in ordered monoids and groups
 

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

@@ -34,65 +34,85 @@ section inv_neg
 variable {G : Type _} [Group G] [Preorder G] [CovariantClass G G (· * ·) (· ≤ ·)]
   [CovariantClass G G (swap (· * ·)) (· ≤ ·)] {s : Set G} {a : G}
 
+#print bddAbove_inv /-
 @[simp, to_additive]
 theorem bddAbove_inv : BddAbove s⁻¹ ↔ BddBelow s :=
   (OrderIso.inv G).bddAbove_preimage
 #align bdd_above_inv bddAbove_inv
 #align bdd_above_neg bddAbove_neg
+-/
 
+#print bddBelow_inv /-
 @[simp, to_additive]
 theorem bddBelow_inv : BddBelow s⁻¹ ↔ BddAbove s :=
   (OrderIso.inv G).bddBelow_preimage
 #align bdd_below_inv bddBelow_inv
 #align bdd_below_neg bddBelow_neg
+-/
 
+#print BddAbove.inv /-
 @[to_additive]
 theorem BddAbove.inv (h : BddAbove s) : BddBelow s⁻¹ :=
   bddBelow_inv.2 h
 #align bdd_above.inv BddAbove.inv
 #align bdd_above.neg BddAbove.neg
+-/
 
+#print BddBelow.inv /-
 @[to_additive]
 theorem BddBelow.inv (h : BddBelow s) : BddAbove s⁻¹ :=
   bddAbove_inv.2 h
 #align bdd_below.inv BddBelow.inv
 #align bdd_below.neg BddBelow.neg
+-/
 
+#print isLUB_inv /-
 @[simp, to_additive]
 theorem isLUB_inv : IsLUB s⁻¹ a ↔ IsGLB s a⁻¹ :=
   (OrderIso.inv G).isLUB_preimage
 #align is_lub_inv isLUB_inv
 #align is_lub_neg isLUB_neg
+-/
 
+#print isLUB_inv' /-
 @[to_additive]
 theorem isLUB_inv' : IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a :=
   (OrderIso.inv G).isLUB_preimage'
 #align is_lub_inv' isLUB_inv'
 #align is_lub_neg' isLUB_neg'
+-/
 
+#print IsGLB.inv /-
 @[to_additive]
 theorem IsGLB.inv (h : IsGLB s a) : IsLUB s⁻¹ a⁻¹ :=
   isLUB_inv'.2 h
 #align is_glb.inv IsGLB.inv
 #align is_glb.neg IsGLB.neg
+-/
 
+#print isGLB_inv /-
 @[simp, to_additive]
 theorem isGLB_inv : IsGLB s⁻¹ a ↔ IsLUB s a⁻¹ :=
   (OrderIso.inv G).isGLB_preimage
 #align is_glb_inv isGLB_inv
 #align is_glb_neg isGLB_neg
+-/
 
+#print isGLB_inv' /-
 @[to_additive]
 theorem isGLB_inv' : IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a :=
   (OrderIso.inv G).isGLB_preimage'
 #align is_glb_inv' isGLB_inv'
 #align is_glb_neg' isGLB_neg'
+-/
 
+#print IsLUB.inv /-
 @[to_additive]
 theorem IsLUB.inv (h : IsLUB s a) : IsGLB s⁻¹ a⁻¹ :=
   isGLB_inv'.2 h
 #align is_lub.inv IsLUB.inv
 #align is_lub.neg IsLUB.neg
+-/
 
 end inv_neg
 
@@ -162,17 +182,21 @@ section Right
 variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (Function.swap (· * ·)) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
+#print ciSup_mul /-
 @[to_additive]
 theorem ciSup_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
   (OrderIso.mulRight a).map_ciSup hf
 #align csupr_mul ciSup_mul
 #align csupr_add ciSup_add
+-/
 
+#print ciSup_div /-
 @[to_additive]
 theorem ciSup_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
   simp only [div_eq_mul_inv, ciSup_mul hf]
 #align csupr_div ciSup_div
 #align csupr_sub ciSup_sub
+-/
 
 end Right
 
@@ -181,11 +205,13 @@ section Left
 variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (· * ·) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
+#print mul_ciSup /-
 @[to_additive]
 theorem mul_ciSup (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
   (OrderIso.mulLeft a).map_ciSup hf
 #align mul_csupr mul_ciSup
 #align add_csupr add_ciSup
+-/
 
 end Left
 

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

@@ -27,7 +27,7 @@ In this file we prove a few facts like “`-s` is bounded above iff `s` is bound
 
 open Function Set
 
-open Pointwise
+open scoped Pointwise
 
 section inv_neg
 
@@ -101,45 +101,57 @@ section mul_add
 variable {M : Type _} [Mul M] [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)]
   [CovariantClass M M (swap (· * ·)) (· ≤ ·)]
 
+#print mul_mem_upperBounds_mul /-
 @[to_additive]
 theorem mul_mem_upperBounds_mul {s t : Set M} {a b : M} (ha : a ∈ upperBounds s)
     (hb : b ∈ upperBounds t) : a * b ∈ upperBounds (s * t) :=
   forall_image2_iff.2 fun x hx y hy => mul_le_mul' (ha hx) (hb hy)
 #align mul_mem_upper_bounds_mul mul_mem_upperBounds_mul
 #align add_mem_upper_bounds_add add_mem_upperBounds_add
+-/
 
+#print subset_upperBounds_mul /-
 @[to_additive]
 theorem subset_upperBounds_mul (s t : Set M) :
     upperBounds s * upperBounds t ⊆ upperBounds (s * t) :=
   image2_subset_iff.2 fun x hx y hy => mul_mem_upperBounds_mul hx hy
 #align subset_upper_bounds_mul subset_upperBounds_mul
 #align subset_upper_bounds_add subset_upperBounds_add
+-/
 
+#print mul_mem_lowerBounds_mul /-
 @[to_additive]
 theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds s)
     (hb : b ∈ lowerBounds t) : a * b ∈ lowerBounds (s * t) :=
   @mul_mem_upperBounds_mul Mᵒᵈ _ _ _ _ _ _ _ _ ha hb
 #align mul_mem_lower_bounds_mul mul_mem_lowerBounds_mul
 #align add_mem_lower_bounds_add add_mem_lowerBounds_add
+-/
 
+#print subset_lowerBounds_mul /-
 @[to_additive]
 theorem subset_lowerBounds_mul (s t : Set M) :
     lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t) :=
   @subset_upperBounds_mul Mᵒᵈ _ _ _ _ _ _
 #align subset_lower_bounds_mul subset_lowerBounds_mul
 #align subset_lower_bounds_add subset_lowerBounds_add
+-/
 
+#print BddAbove.mul /-
 @[to_additive]
 theorem BddAbove.mul {s t : Set M} (hs : BddAbove s) (ht : BddAbove t) : BddAbove (s * t) :=
   (hs.mul ht).mono (subset_upperBounds_mul s t)
 #align bdd_above.mul BddAbove.mul
 #align bdd_above.add BddAbove.add
+-/
 
+#print BddBelow.mul /-
 @[to_additive]
 theorem BddBelow.mul {s t : Set M} (hs : BddBelow s) (ht : BddBelow t) : BddBelow (s * t) :=
   (hs.mul ht).mono (subset_lowerBounds_mul s t)
 #align bdd_below.mul BddBelow.mul
 #align bdd_below.add BddBelow.add
+-/
 
 end mul_add
 

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

@@ -34,120 +34,60 @@ section inv_neg
 variable {G : Type _} [Group G] [Preorder G] [CovariantClass G G (· * ·) (· ≤ ·)]
   [CovariantClass G G (swap (· * ·)) (· ≤ ·)] {s : Set G} {a : G}
 
-/- warning: bdd_above_inv -> bddAbove_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, Iff (BddAbove.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)) (BddBelow.{u1} G _inst_2 s)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.110 : G) (x._@.Mathlib.Algebra.Bounds._hyg.112 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.110 x._@.Mathlib.Algebra.Bounds._hyg.112) (fun (x._@.Mathlib.Algebra.Bounds._hyg.125 : G) (x._@.Mathlib.Algebra.Bounds._hyg.127 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.125 x._@.Mathlib.Algebra.Bounds._hyg.127)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.147 : G) (x._@.Mathlib.Algebra.Bounds._hyg.149 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.147 x._@.Mathlib.Algebra.Bounds._hyg.149)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.162 : G) (x._@.Mathlib.Algebra.Bounds._hyg.164 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.162 x._@.Mathlib.Algebra.Bounds._hyg.164)] {s : Set.{u1} G}, Iff (BddAbove.{u1} G _inst_2 (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_1))))) s)) (BddBelow.{u1} G _inst_2 s)
-Case conversion may be inaccurate. Consider using '#align bdd_above_inv bddAbove_invₓ'. -/
 @[simp, to_additive]
 theorem bddAbove_inv : BddAbove s⁻¹ ↔ BddBelow s :=
   (OrderIso.inv G).bddAbove_preimage
 #align bdd_above_inv bddAbove_inv
 #align bdd_above_neg bddAbove_neg
 
-/- warning: bdd_below_inv -> bddBelow_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, Iff (BddBelow.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)) (BddAbove.{u1} G _inst_2 s)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.209 : G) (x._@.Mathlib.Algebra.Bounds._hyg.211 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.209 x._@.Mathlib.Algebra.Bounds._hyg.211) (fun (x._@.Mathlib.Algebra.Bounds._hyg.224 : G) (x._@.Mathlib.Algebra.Bounds._hyg.226 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.224 x._@.Mathlib.Algebra.Bounds._hyg.226)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.246 : G) (x._@.Mathlib.Algebra.Bounds._hyg.248 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.246 x._@.Mathlib.Algebra.Bounds._hyg.248)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.261 : G) (x._@.Mathlib.Algebra.Bounds._hyg.263 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.261 x._@.Mathlib.Algebra.Bounds._hyg.263)] {s : Set.{u1} G}, Iff (BddBelow.{u1} G _inst_2 (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_1))))) s)) (BddAbove.{u1} G _inst_2 s)
-Case conversion may be inaccurate. Consider using '#align bdd_below_inv bddBelow_invₓ'. -/
 @[simp, to_additive]
 theorem bddBelow_inv : BddBelow s⁻¹ ↔ BddAbove s :=
   (OrderIso.inv G).bddBelow_preimage
 #align bdd_below_inv bddBelow_inv
 #align bdd_below_neg bddBelow_neg
 
-/- warning: bdd_above.inv -> BddAbove.inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, (BddAbove.{u1} G _inst_2 s) -> (BddBelow.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.311 : G) (x._@.Mathlib.Algebra.Bounds._hyg.313 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.311 x._@.Mathlib.Algebra.Bounds._hyg.313) (fun (x._@.Mathlib.Algebra.Bounds._hyg.326 : G) (x._@.Mathlib.Algebra.Bounds._hyg.328 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.326 x._@.Mathlib.Algebra.Bounds._hyg.328)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.348 : G) (x._@.Mathlib.Algebra.Bounds._hyg.350 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.348 x._@.Mathlib.Algebra.Bounds._hyg.350)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.363 : G) (x._@.Mathlib.Algebra.Bounds._hyg.365 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.363 x._@.Mathlib.Algebra.Bounds._hyg.365)] {s : Set.{u1} G}, (BddAbove.{u1} G _inst_2 s) -> (BddBelow.{u1} G _inst_2 (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_1))))) s))
-Case conversion may be inaccurate. Consider using '#align bdd_above.inv BddAbove.invₓ'. -/
 @[to_additive]
 theorem BddAbove.inv (h : BddAbove s) : BddBelow s⁻¹ :=
   bddBelow_inv.2 h
 #align bdd_above.inv BddAbove.inv
 #align bdd_above.neg BddAbove.neg
 
-/- warning: bdd_below.inv -> BddBelow.inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, (BddBelow.{u1} G _inst_2 s) -> (BddAbove.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.408 : G) (x._@.Mathlib.Algebra.Bounds._hyg.410 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.408 x._@.Mathlib.Algebra.Bounds._hyg.410) (fun (x._@.Mathlib.Algebra.Bounds._hyg.423 : G) (x._@.Mathlib.Algebra.Bounds._hyg.425 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.423 x._@.Mathlib.Algebra.Bounds._hyg.425)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.445 : G) (x._@.Mathlib.Algebra.Bounds._hyg.447 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.445 x._@.Mathlib.Algebra.Bounds._hyg.447)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.460 : G) (x._@.Mathlib.Algebra.Bounds._hyg.462 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.460 x._@.Mathlib.Algebra.Bounds._hyg.462)] {s : Set.{u1} G}, (BddBelow.{u1} G _inst_2 s) -> (BddAbove.{u1} G _inst_2 (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_1))))) s))
-Case conversion may be inaccurate. Consider using '#align bdd_below.inv BddBelow.invₓ'. -/
 @[to_additive]
 theorem BddBelow.inv (h : BddBelow s) : BddAbove s⁻¹ :=
   bddAbove_inv.2 h
 #align bdd_below.inv BddBelow.inv
 #align bdd_below.neg BddBelow.neg
 
-/- warning: is_lub_inv -> isLUB_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) a) (IsGLB.{u1} G _inst_2 s (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.502 : G) (x._@.Mathlib.Algebra.Bounds._hyg.504 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.502 x._@.Mathlib.Algebra.Bounds._hyg.504) (fun (x._@.Mathlib.Algebra.Bounds._hyg.517 : G) (x._@.Mathlib.Algebra.Bounds._hyg.519 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.517 x._@.Mathlib.Algebra.Bounds._hyg.519)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.539 : G) (x._@.Mathlib.Algebra.Bounds._hyg.541 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.539 x._@.Mathlib.Algebra.Bounds._hyg.541)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.554 : G) (x._@.Mathlib.Algebra.Bounds._hyg.556 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.554 x._@.Mathlib.Algebra.Bounds._hyg.556)] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (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_1))))) s) a) (IsGLB.{u1} G _inst_2 s (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align is_lub_inv isLUB_invₓ'. -/
 @[simp, to_additive]
 theorem isLUB_inv : IsLUB s⁻¹ a ↔ IsGLB s a⁻¹ :=
   (OrderIso.inv G).isLUB_preimage
 #align is_lub_inv isLUB_inv
 #align is_lub_neg isLUB_neg
 
-/- warning: is_lub_inv' -> isLUB_inv' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a)) (IsGLB.{u1} G _inst_2 s a)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.606 : G) (x._@.Mathlib.Algebra.Bounds._hyg.608 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.606 x._@.Mathlib.Algebra.Bounds._hyg.608) (fun (x._@.Mathlib.Algebra.Bounds._hyg.621 : G) (x._@.Mathlib.Algebra.Bounds._hyg.623 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.621 x._@.Mathlib.Algebra.Bounds._hyg.623)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.643 : G) (x._@.Mathlib.Algebra.Bounds._hyg.645 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.643 x._@.Mathlib.Algebra.Bounds._hyg.645)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.658 : G) (x._@.Mathlib.Algebra.Bounds._hyg.660 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.658 x._@.Mathlib.Algebra.Bounds._hyg.660)] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a)) (IsGLB.{u1} G _inst_2 s a)
-Case conversion may be inaccurate. Consider using '#align is_lub_inv' isLUB_inv'ₓ'. -/
 @[to_additive]
 theorem isLUB_inv' : IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a :=
   (OrderIso.inv G).isLUB_preimage'
 #align is_lub_inv' isLUB_inv'
 #align is_lub_neg' isLUB_neg'
 
-/- warning: is_glb.inv -> IsGLB.inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, (IsGLB.{u1} G _inst_2 s a) -> (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.713 : G) (x._@.Mathlib.Algebra.Bounds._hyg.715 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.713 x._@.Mathlib.Algebra.Bounds._hyg.715) (fun (x._@.Mathlib.Algebra.Bounds._hyg.728 : G) (x._@.Mathlib.Algebra.Bounds._hyg.730 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.728 x._@.Mathlib.Algebra.Bounds._hyg.730)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.750 : G) (x._@.Mathlib.Algebra.Bounds._hyg.752 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.750 x._@.Mathlib.Algebra.Bounds._hyg.752)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.765 : G) (x._@.Mathlib.Algebra.Bounds._hyg.767 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.765 x._@.Mathlib.Algebra.Bounds._hyg.767)] {s : Set.{u1} G} {a : G}, (IsGLB.{u1} G _inst_2 s a) -> (IsLUB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align is_glb.inv IsGLB.invₓ'. -/
 @[to_additive]
 theorem IsGLB.inv (h : IsGLB s a) : IsLUB s⁻¹ a⁻¹ :=
   isLUB_inv'.2 h
 #align is_glb.inv IsGLB.inv
 #align is_glb.neg IsGLB.neg
 
-/- warning: is_glb_inv -> isGLB_inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) a) (IsLUB.{u1} G _inst_2 s (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.812 : G) (x._@.Mathlib.Algebra.Bounds._hyg.814 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.812 x._@.Mathlib.Algebra.Bounds._hyg.814) (fun (x._@.Mathlib.Algebra.Bounds._hyg.827 : G) (x._@.Mathlib.Algebra.Bounds._hyg.829 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.827 x._@.Mathlib.Algebra.Bounds._hyg.829)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.849 : G) (x._@.Mathlib.Algebra.Bounds._hyg.851 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.849 x._@.Mathlib.Algebra.Bounds._hyg.851)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.864 : G) (x._@.Mathlib.Algebra.Bounds._hyg.866 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.864 x._@.Mathlib.Algebra.Bounds._hyg.866)] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (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_1))))) s) a) (IsLUB.{u1} G _inst_2 s (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align is_glb_inv isGLB_invₓ'. -/
 @[simp, to_additive]
 theorem isGLB_inv : IsGLB s⁻¹ a ↔ IsLUB s a⁻¹ :=
   (OrderIso.inv G).isGLB_preimage
 #align is_glb_inv isGLB_inv
 #align is_glb_neg isGLB_neg
 
-/- warning: is_glb_inv' -> isGLB_inv' is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a)) (IsLUB.{u1} G _inst_2 s a)
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.916 : G) (x._@.Mathlib.Algebra.Bounds._hyg.918 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.916 x._@.Mathlib.Algebra.Bounds._hyg.918) (fun (x._@.Mathlib.Algebra.Bounds._hyg.931 : G) (x._@.Mathlib.Algebra.Bounds._hyg.933 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.931 x._@.Mathlib.Algebra.Bounds._hyg.933)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.953 : G) (x._@.Mathlib.Algebra.Bounds._hyg.955 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.953 x._@.Mathlib.Algebra.Bounds._hyg.955)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.968 : G) (x._@.Mathlib.Algebra.Bounds._hyg.970 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.968 x._@.Mathlib.Algebra.Bounds._hyg.970)] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a)) (IsLUB.{u1} G _inst_2 s a)
-Case conversion may be inaccurate. Consider using '#align is_glb_inv' isGLB_inv'ₓ'. -/
 @[to_additive]
 theorem isGLB_inv' : IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a :=
   (OrderIso.inv G).isGLB_preimage'
 #align is_glb_inv' isGLB_inv'
 #align is_glb_neg' isGLB_neg'
 
-/- warning: is_lub.inv -> IsLUB.inv is a dubious translation:
-lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, (IsLUB.{u1} G _inst_2 s a) -> (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
-but is expected to have type
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.1023 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1025 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1023 x._@.Mathlib.Algebra.Bounds._hyg.1025) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1038 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1040 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1038 x._@.Mathlib.Algebra.Bounds._hyg.1040)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1060 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1062 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1060 x._@.Mathlib.Algebra.Bounds._hyg.1062)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1075 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1077 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1075 x._@.Mathlib.Algebra.Bounds._hyg.1077)] {s : Set.{u1} G} {a : G}, (IsLUB.{u1} G _inst_2 s a) -> (IsGLB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align is_lub.inv IsLUB.invₓ'. -/
 @[to_additive]
 theorem IsLUB.inv (h : IsLUB s a) : IsGLB s⁻¹ a⁻¹ :=
   isGLB_inv'.2 h
@@ -161,12 +101,6 @@ section mul_add
 variable {M : Type _} [Mul M] [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)]
   [CovariantClass M M (swap (· * ·)) (· ≤ ·)]
 
-/- warning: mul_mem_upper_bounds_mul -> mul_mem_upperBounds_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (upperBounds.{u1} M _inst_2 s)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (upperBounds.{u1} M _inst_2 t)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1208 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1210 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1208 x._@.Mathlib.Algebra.Bounds._hyg.1210) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1223 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1225 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1223 x._@.Mathlib.Algebra.Bounds._hyg.1225)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1245 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1247 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1245 x._@.Mathlib.Algebra.Bounds._hyg.1247)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1260 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1262 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1260 x._@.Mathlib.Algebra.Bounds._hyg.1262)] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (upperBounds.{u1} M _inst_2 s)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (upperBounds.{u1} M _inst_2 t)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
-Case conversion may be inaccurate. Consider using '#align mul_mem_upper_bounds_mul mul_mem_upperBounds_mulₓ'. -/
 @[to_additive]
 theorem mul_mem_upperBounds_mul {s t : Set M} {a b : M} (ha : a ∈ upperBounds s)
     (hb : b ∈ upperBounds t) : a * b ∈ upperBounds (s * t) :=
@@ -174,12 +108,6 @@ theorem mul_mem_upperBounds_mul {s t : Set M} {a b : M} (ha : a ∈ upperBounds
 #align mul_mem_upper_bounds_mul mul_mem_upperBounds_mul
 #align add_mem_upper_bounds_add add_mem_upperBounds_add
 
-/- warning: subset_upper_bounds_mul -> subset_upperBounds_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (upperBounds.{u1} M _inst_2 s) (upperBounds.{u1} M _inst_2 t)) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1341 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1343 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1341 x._@.Mathlib.Algebra.Bounds._hyg.1343) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1356 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1358 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1356 x._@.Mathlib.Algebra.Bounds._hyg.1358)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1378 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1380 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1378 x._@.Mathlib.Algebra.Bounds._hyg.1380)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1393 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1395 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1393 x._@.Mathlib.Algebra.Bounds._hyg.1395)] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (upperBounds.{u1} M _inst_2 s) (upperBounds.{u1} M _inst_2 t)) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-Case conversion may be inaccurate. Consider using '#align subset_upper_bounds_mul subset_upperBounds_mulₓ'. -/
 @[to_additive]
 theorem subset_upperBounds_mul (s t : Set M) :
     upperBounds s * upperBounds t ⊆ upperBounds (s * t) :=
@@ -187,12 +115,6 @@ theorem subset_upperBounds_mul (s t : Set M) :
 #align subset_upper_bounds_mul subset_upperBounds_mul
 #align subset_upper_bounds_add subset_upperBounds_add
 
-/- warning: mul_mem_lower_bounds_mul -> mul_mem_lowerBounds_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (lowerBounds.{u1} M _inst_2 s)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (lowerBounds.{u1} M _inst_2 t)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1456 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1458 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1456 x._@.Mathlib.Algebra.Bounds._hyg.1458) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1471 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1473 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1471 x._@.Mathlib.Algebra.Bounds._hyg.1473)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1493 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1495 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1493 x._@.Mathlib.Algebra.Bounds._hyg.1495)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1508 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1510 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1508 x._@.Mathlib.Algebra.Bounds._hyg.1510)] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (lowerBounds.{u1} M _inst_2 s)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (lowerBounds.{u1} M _inst_2 t)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
-Case conversion may be inaccurate. Consider using '#align mul_mem_lower_bounds_mul mul_mem_lowerBounds_mulₓ'. -/
 @[to_additive]
 theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds s)
     (hb : b ∈ lowerBounds t) : a * b ∈ lowerBounds (s * t) :=
@@ -200,12 +122,6 @@ theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds
 #align mul_mem_lower_bounds_mul mul_mem_lowerBounds_mul
 #align add_mem_lower_bounds_add add_mem_lowerBounds_add
 
-/- warning: subset_lower_bounds_mul -> subset_lowerBounds_mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (lowerBounds.{u1} M _inst_2 s) (lowerBounds.{u1} M _inst_2 t)) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1582 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1584 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1582 x._@.Mathlib.Algebra.Bounds._hyg.1584) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1597 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1599 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1597 x._@.Mathlib.Algebra.Bounds._hyg.1599)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1619 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1621 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1619 x._@.Mathlib.Algebra.Bounds._hyg.1621)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1634 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1636 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1634 x._@.Mathlib.Algebra.Bounds._hyg.1636)] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (lowerBounds.{u1} M _inst_2 s) (lowerBounds.{u1} M _inst_2 t)) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-Case conversion may be inaccurate. Consider using '#align subset_lower_bounds_mul subset_lowerBounds_mulₓ'. -/
 @[to_additive]
 theorem subset_lowerBounds_mul (s t : Set M) :
     lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t) :=
@@ -213,24 +129,12 @@ theorem subset_lowerBounds_mul (s t : Set M) :
 #align subset_lower_bounds_mul subset_lowerBounds_mul
 #align subset_lower_bounds_add subset_lowerBounds_add
 
-/- warning: bdd_above.mul -> BddAbove.mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M}, (BddAbove.{u1} M _inst_2 s) -> (BddAbove.{u1} M _inst_2 t) -> (BddAbove.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1695 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1697 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1695 x._@.Mathlib.Algebra.Bounds._hyg.1697) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1710 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1712 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1710 x._@.Mathlib.Algebra.Bounds._hyg.1712)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1732 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1734 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1732 x._@.Mathlib.Algebra.Bounds._hyg.1734)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1747 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1749 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1747 x._@.Mathlib.Algebra.Bounds._hyg.1749)] {s : Set.{u1} M} {t : Set.{u1} M}, (BddAbove.{u1} M _inst_2 s) -> (BddAbove.{u1} M _inst_2 t) -> (BddAbove.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-Case conversion may be inaccurate. Consider using '#align bdd_above.mul BddAbove.mulₓ'. -/
 @[to_additive]
 theorem BddAbove.mul {s t : Set M} (hs : BddAbove s) (ht : BddAbove t) : BddAbove (s * t) :=
   (hs.mul ht).mono (subset_upperBounds_mul s t)
 #align bdd_above.mul BddAbove.mul
 #align bdd_above.add BddAbove.add
 
-/- warning: bdd_below.mul -> BddBelow.mul is a dubious translation:
-lean 3 declaration is
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M}, (BddBelow.{u1} M _inst_2 s) -> (BddBelow.{u1} M _inst_2 t) -> (BddBelow.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-but is expected to have type
-  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1807 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1809 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1807 x._@.Mathlib.Algebra.Bounds._hyg.1809) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1822 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1824 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1822 x._@.Mathlib.Algebra.Bounds._hyg.1824)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1844 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1846 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1844 x._@.Mathlib.Algebra.Bounds._hyg.1846)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1859 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1861 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1859 x._@.Mathlib.Algebra.Bounds._hyg.1861)] {s : Set.{u1} M} {t : Set.{u1} M}, (BddBelow.{u1} M _inst_2 s) -> (BddBelow.{u1} M _inst_2 t) -> (BddBelow.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
-Case conversion may be inaccurate. Consider using '#align bdd_below.mul BddBelow.mulₓ'. -/
 @[to_additive]
 theorem BddBelow.mul {s t : Set M} (hs : BddBelow s) (ht : BddBelow t) : BddBelow (s * t) :=
   (hs.mul ht).mono (subset_lowerBounds_mul s t)
@@ -246,24 +150,12 @@ section Right
 variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (Function.swap (· * ·)) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
-/- warning: csupr_mul -> ciSup_mul is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toHasLe.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
-but is expected to have type
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1982 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1984 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1982 x._@.Mathlib.Algebra.Bounds._hyg.1984)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1997 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1999 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.1997 x._@.Mathlib.Algebra.Bounds._hyg.1999)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
-Case conversion may be inaccurate. Consider using '#align csupr_mul ciSup_mulₓ'. -/
 @[to_additive]
 theorem ciSup_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
   (OrderIso.mulRight a).map_ciSup hf
 #align csupr_mul ciSup_mul
 #align csupr_add ciSup_add
 
-/- warning: csupr_div -> ciSup_div is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toHasLe.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
-but is expected to have type
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2087 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2089 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2087 x._@.Mathlib.Algebra.Bounds._hyg.2089)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2102 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2104 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2102 x._@.Mathlib.Algebra.Bounds._hyg.2104)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
-Case conversion may be inaccurate. Consider using '#align csupr_div ciSup_divₓ'. -/
 @[to_additive]
 theorem ciSup_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
   simp only [div_eq_mul_inv, ciSup_mul hf]
@@ -277,12 +169,6 @@ section Left
 variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (· * ·) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
-/- warning: mul_csupr -> mul_ciSup is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))))) (LE.le.{u2} G (Preorder.toHasLe.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
-but is expected to have type
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.2247 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2249 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2247 x._@.Mathlib.Algebra.Bounds._hyg.2249) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2262 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2264 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2262 x._@.Mathlib.Algebra.Bounds._hyg.2264)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
-Case conversion may be inaccurate. Consider using '#align mul_csupr mul_ciSupₓ'. -/
 @[to_additive]
 theorem mul_ciSup (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
   (OrderIso.mulLeft a).map_ciSup hf

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

@@ -36,7 +36,7 @@ variable {G : Type _} [Group G] [Preorder G] [CovariantClass G G (· * ·) (· 
 
 /- warning: bdd_above_inv -> bddAbove_inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G}, Iff (BddAbove.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)) (BddBelow.{u1} G _inst_2 s)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, Iff (BddAbove.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)) (BddBelow.{u1} G _inst_2 s)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.110 : G) (x._@.Mathlib.Algebra.Bounds._hyg.112 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.110 x._@.Mathlib.Algebra.Bounds._hyg.112) (fun (x._@.Mathlib.Algebra.Bounds._hyg.125 : G) (x._@.Mathlib.Algebra.Bounds._hyg.127 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.125 x._@.Mathlib.Algebra.Bounds._hyg.127)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.147 : G) (x._@.Mathlib.Algebra.Bounds._hyg.149 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.147 x._@.Mathlib.Algebra.Bounds._hyg.149)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.162 : G) (x._@.Mathlib.Algebra.Bounds._hyg.164 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.162 x._@.Mathlib.Algebra.Bounds._hyg.164)] {s : Set.{u1} G}, Iff (BddAbove.{u1} G _inst_2 (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_1))))) s)) (BddBelow.{u1} G _inst_2 s)
 Case conversion may be inaccurate. Consider using '#align bdd_above_inv bddAbove_invₓ'. -/
@@ -48,7 +48,7 @@ theorem bddAbove_inv : BddAbove s⁻¹ ↔ BddBelow s :=
 
 /- warning: bdd_below_inv -> bddBelow_inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G}, Iff (BddBelow.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)) (BddAbove.{u1} G _inst_2 s)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, Iff (BddBelow.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s)) (BddAbove.{u1} G _inst_2 s)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.209 : G) (x._@.Mathlib.Algebra.Bounds._hyg.211 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.209 x._@.Mathlib.Algebra.Bounds._hyg.211) (fun (x._@.Mathlib.Algebra.Bounds._hyg.224 : G) (x._@.Mathlib.Algebra.Bounds._hyg.226 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.224 x._@.Mathlib.Algebra.Bounds._hyg.226)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.246 : G) (x._@.Mathlib.Algebra.Bounds._hyg.248 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.246 x._@.Mathlib.Algebra.Bounds._hyg.248)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.261 : G) (x._@.Mathlib.Algebra.Bounds._hyg.263 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.261 x._@.Mathlib.Algebra.Bounds._hyg.263)] {s : Set.{u1} G}, Iff (BddBelow.{u1} G _inst_2 (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_1))))) s)) (BddAbove.{u1} G _inst_2 s)
 Case conversion may be inaccurate. Consider using '#align bdd_below_inv bddBelow_invₓ'. -/
@@ -60,7 +60,7 @@ theorem bddBelow_inv : BddBelow s⁻¹ ↔ BddAbove s :=
 
 /- warning: bdd_above.inv -> BddAbove.inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G}, (BddAbove.{u1} G _inst_2 s) -> (BddBelow.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, (BddAbove.{u1} G _inst_2 s) -> (BddBelow.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.311 : G) (x._@.Mathlib.Algebra.Bounds._hyg.313 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.311 x._@.Mathlib.Algebra.Bounds._hyg.313) (fun (x._@.Mathlib.Algebra.Bounds._hyg.326 : G) (x._@.Mathlib.Algebra.Bounds._hyg.328 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.326 x._@.Mathlib.Algebra.Bounds._hyg.328)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.348 : G) (x._@.Mathlib.Algebra.Bounds._hyg.350 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.348 x._@.Mathlib.Algebra.Bounds._hyg.350)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.363 : G) (x._@.Mathlib.Algebra.Bounds._hyg.365 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.363 x._@.Mathlib.Algebra.Bounds._hyg.365)] {s : Set.{u1} G}, (BddAbove.{u1} G _inst_2 s) -> (BddBelow.{u1} G _inst_2 (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_1))))) s))
 Case conversion may be inaccurate. Consider using '#align bdd_above.inv BddAbove.invₓ'. -/
@@ -72,7 +72,7 @@ theorem BddAbove.inv (h : BddAbove s) : BddBelow s⁻¹ :=
 
 /- warning: bdd_below.inv -> BddBelow.inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G}, (BddBelow.{u1} G _inst_2 s) -> (BddAbove.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G}, (BddBelow.{u1} G _inst_2 s) -> (BddAbove.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.408 : G) (x._@.Mathlib.Algebra.Bounds._hyg.410 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.408 x._@.Mathlib.Algebra.Bounds._hyg.410) (fun (x._@.Mathlib.Algebra.Bounds._hyg.423 : G) (x._@.Mathlib.Algebra.Bounds._hyg.425 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.423 x._@.Mathlib.Algebra.Bounds._hyg.425)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.445 : G) (x._@.Mathlib.Algebra.Bounds._hyg.447 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.445 x._@.Mathlib.Algebra.Bounds._hyg.447)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.460 : G) (x._@.Mathlib.Algebra.Bounds._hyg.462 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.460 x._@.Mathlib.Algebra.Bounds._hyg.462)] {s : Set.{u1} G}, (BddBelow.{u1} G _inst_2 s) -> (BddAbove.{u1} G _inst_2 (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_1))))) s))
 Case conversion may be inaccurate. Consider using '#align bdd_below.inv BddBelow.invₓ'. -/
@@ -84,7 +84,7 @@ theorem BddBelow.inv (h : BddBelow s) : BddAbove s⁻¹ :=
 
 /- warning: is_lub_inv -> isLUB_inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) a) (IsGLB.{u1} G _inst_2 s (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) a) (IsGLB.{u1} G _inst_2 s (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.502 : G) (x._@.Mathlib.Algebra.Bounds._hyg.504 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.502 x._@.Mathlib.Algebra.Bounds._hyg.504) (fun (x._@.Mathlib.Algebra.Bounds._hyg.517 : G) (x._@.Mathlib.Algebra.Bounds._hyg.519 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.517 x._@.Mathlib.Algebra.Bounds._hyg.519)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.539 : G) (x._@.Mathlib.Algebra.Bounds._hyg.541 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.539 x._@.Mathlib.Algebra.Bounds._hyg.541)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.554 : G) (x._@.Mathlib.Algebra.Bounds._hyg.556 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.554 x._@.Mathlib.Algebra.Bounds._hyg.556)] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (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_1))))) s) a) (IsGLB.{u1} G _inst_2 s (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align is_lub_inv isLUB_invₓ'. -/
@@ -96,7 +96,7 @@ theorem isLUB_inv : IsLUB s⁻¹ a ↔ IsGLB s a⁻¹ :=
 
 /- warning: is_lub_inv' -> isLUB_inv' is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a)) (IsGLB.{u1} G _inst_2 s a)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a)) (IsGLB.{u1} G _inst_2 s a)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.606 : G) (x._@.Mathlib.Algebra.Bounds._hyg.608 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.606 x._@.Mathlib.Algebra.Bounds._hyg.608) (fun (x._@.Mathlib.Algebra.Bounds._hyg.621 : G) (x._@.Mathlib.Algebra.Bounds._hyg.623 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.621 x._@.Mathlib.Algebra.Bounds._hyg.623)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.643 : G) (x._@.Mathlib.Algebra.Bounds._hyg.645 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.643 x._@.Mathlib.Algebra.Bounds._hyg.645)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.658 : G) (x._@.Mathlib.Algebra.Bounds._hyg.660 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.658 x._@.Mathlib.Algebra.Bounds._hyg.660)] {s : Set.{u1} G} {a : G}, Iff (IsLUB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a)) (IsGLB.{u1} G _inst_2 s a)
 Case conversion may be inaccurate. Consider using '#align is_lub_inv' isLUB_inv'ₓ'. -/
@@ -108,7 +108,7 @@ theorem isLUB_inv' : IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a :=
 
 /- warning: is_glb.inv -> IsGLB.inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, (IsGLB.{u1} G _inst_2 s a) -> (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, (IsGLB.{u1} G _inst_2 s a) -> (IsLUB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.713 : G) (x._@.Mathlib.Algebra.Bounds._hyg.715 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.713 x._@.Mathlib.Algebra.Bounds._hyg.715) (fun (x._@.Mathlib.Algebra.Bounds._hyg.728 : G) (x._@.Mathlib.Algebra.Bounds._hyg.730 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.728 x._@.Mathlib.Algebra.Bounds._hyg.730)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.750 : G) (x._@.Mathlib.Algebra.Bounds._hyg.752 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.750 x._@.Mathlib.Algebra.Bounds._hyg.752)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.765 : G) (x._@.Mathlib.Algebra.Bounds._hyg.767 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.765 x._@.Mathlib.Algebra.Bounds._hyg.767)] {s : Set.{u1} G} {a : G}, (IsGLB.{u1} G _inst_2 s a) -> (IsLUB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align is_glb.inv IsGLB.invₓ'. -/
@@ -120,7 +120,7 @@ theorem IsGLB.inv (h : IsGLB s a) : IsLUB s⁻¹ a⁻¹ :=
 
 /- warning: is_glb_inv -> isGLB_inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) a) (IsLUB.{u1} G _inst_2 s (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) a) (IsLUB.{u1} G _inst_2 s (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.812 : G) (x._@.Mathlib.Algebra.Bounds._hyg.814 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.812 x._@.Mathlib.Algebra.Bounds._hyg.814) (fun (x._@.Mathlib.Algebra.Bounds._hyg.827 : G) (x._@.Mathlib.Algebra.Bounds._hyg.829 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.827 x._@.Mathlib.Algebra.Bounds._hyg.829)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.849 : G) (x._@.Mathlib.Algebra.Bounds._hyg.851 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.849 x._@.Mathlib.Algebra.Bounds._hyg.851)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.864 : G) (x._@.Mathlib.Algebra.Bounds._hyg.866 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.864 x._@.Mathlib.Algebra.Bounds._hyg.866)] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (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_1))))) s) a) (IsLUB.{u1} G _inst_2 s (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align is_glb_inv isGLB_invₓ'. -/
@@ -132,7 +132,7 @@ theorem isGLB_inv : IsGLB s⁻¹ a ↔ IsLUB s a⁻¹ :=
 
 /- warning: is_glb_inv' -> isGLB_inv' is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a)) (IsLUB.{u1} G _inst_2 s a)
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a)) (IsLUB.{u1} G _inst_2 s a)
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.916 : G) (x._@.Mathlib.Algebra.Bounds._hyg.918 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.916 x._@.Mathlib.Algebra.Bounds._hyg.918) (fun (x._@.Mathlib.Algebra.Bounds._hyg.931 : G) (x._@.Mathlib.Algebra.Bounds._hyg.933 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.931 x._@.Mathlib.Algebra.Bounds._hyg.933)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.953 : G) (x._@.Mathlib.Algebra.Bounds._hyg.955 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.953 x._@.Mathlib.Algebra.Bounds._hyg.955)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.968 : G) (x._@.Mathlib.Algebra.Bounds._hyg.970 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.968 x._@.Mathlib.Algebra.Bounds._hyg.970)] {s : Set.{u1} G} {a : G}, Iff (IsGLB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a)) (IsLUB.{u1} G _inst_2 s a)
 Case conversion may be inaccurate. Consider using '#align is_glb_inv' isGLB_inv'ₓ'. -/
@@ -144,7 +144,7 @@ theorem isGLB_inv' : IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a :=
 
 /- warning: is_lub.inv -> IsLUB.inv is a dubious translation:
 lean 3 declaration is
-  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, (IsLUB.{u1} G _inst_2 s a) -> (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
+  forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toHasMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))))) (LE.le.{u1} G (Preorder.toHasLe.{u1} G _inst_2))] {s : Set.{u1} G} {a : G}, (IsLUB.{u1} G _inst_2 s a) -> (IsGLB.{u1} G _inst_2 (Inv.inv.{u1} (Set.{u1} G) (Set.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))) s) (Inv.inv.{u1} G (DivInvMonoid.toHasInv.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1)) a))
 but is expected to have type
   forall {G : Type.{u1}} [_inst_1 : Group.{u1} G] [_inst_2 : Preorder.{u1} G] [_inst_3 : CovariantClass.{u1, u1} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.1023 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1025 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1023 x._@.Mathlib.Algebra.Bounds._hyg.1025) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1038 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1040 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1038 x._@.Mathlib.Algebra.Bounds._hyg.1040)] [_inst_4 : CovariantClass.{u1, u1} G G (Function.swap.{succ u1, succ u1, succ u1} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1060 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1062 : G) => HMul.hMul.{u1, u1, u1} G G G (instHMul.{u1} G (MulOneClass.toMul.{u1} G (Monoid.toMulOneClass.{u1} G (DivInvMonoid.toMonoid.{u1} G (Group.toDivInvMonoid.{u1} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1060 x._@.Mathlib.Algebra.Bounds._hyg.1062)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1075 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1077 : G) => LE.le.{u1} G (Preorder.toLE.{u1} G _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1075 x._@.Mathlib.Algebra.Bounds._hyg.1077)] {s : Set.{u1} G} {a : G}, (IsLUB.{u1} G _inst_2 s a) -> (IsGLB.{u1} G _inst_2 (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_1))))) s) (Inv.inv.{u1} G (InvOneClass.toInv.{u1} G (DivInvOneMonoid.toInvOneClass.{u1} G (DivisionMonoid.toDivInvOneMonoid.{u1} G (Group.toDivisionMonoid.{u1} G _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align is_lub.inv IsLUB.invₓ'. -/
@@ -161,57 +161,81 @@ section mul_add
 variable {M : Type _} [Mul M] [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)]
   [CovariantClass M M (swap (· * ·)) (· ≤ ·)]
 
-#print mul_mem_upperBounds_mul /-
+/- warning: mul_mem_upper_bounds_mul -> mul_mem_upperBounds_mul is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (upperBounds.{u1} M _inst_2 s)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (upperBounds.{u1} M _inst_2 t)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1208 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1210 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1208 x._@.Mathlib.Algebra.Bounds._hyg.1210) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1223 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1225 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1223 x._@.Mathlib.Algebra.Bounds._hyg.1225)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1245 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1247 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1245 x._@.Mathlib.Algebra.Bounds._hyg.1247)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1260 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1262 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1260 x._@.Mathlib.Algebra.Bounds._hyg.1262)] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (upperBounds.{u1} M _inst_2 s)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (upperBounds.{u1} M _inst_2 t)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
+Case conversion may be inaccurate. Consider using '#align mul_mem_upper_bounds_mul mul_mem_upperBounds_mulₓ'. -/
 @[to_additive]
 theorem mul_mem_upperBounds_mul {s t : Set M} {a b : M} (ha : a ∈ upperBounds s)
     (hb : b ∈ upperBounds t) : a * b ∈ upperBounds (s * t) :=
   forall_image2_iff.2 fun x hx y hy => mul_le_mul' (ha hx) (hb hy)
 #align mul_mem_upper_bounds_mul mul_mem_upperBounds_mul
 #align add_mem_upper_bounds_add add_mem_upperBounds_add
--/
 
-#print subset_upperBounds_mul /-
+/- warning: subset_upper_bounds_mul -> subset_upperBounds_mul is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (upperBounds.{u1} M _inst_2 s) (upperBounds.{u1} M _inst_2 t)) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1341 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1343 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1341 x._@.Mathlib.Algebra.Bounds._hyg.1343) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1356 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1358 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1356 x._@.Mathlib.Algebra.Bounds._hyg.1358)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1378 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1380 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1378 x._@.Mathlib.Algebra.Bounds._hyg.1380)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1393 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1395 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1393 x._@.Mathlib.Algebra.Bounds._hyg.1395)] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (upperBounds.{u1} M _inst_2 s) (upperBounds.{u1} M _inst_2 t)) (upperBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+Case conversion may be inaccurate. Consider using '#align subset_upper_bounds_mul subset_upperBounds_mulₓ'. -/
 @[to_additive]
 theorem subset_upperBounds_mul (s t : Set M) :
     upperBounds s * upperBounds t ⊆ upperBounds (s * t) :=
   image2_subset_iff.2 fun x hx y hy => mul_mem_upperBounds_mul hx hy
 #align subset_upper_bounds_mul subset_upperBounds_mul
 #align subset_upper_bounds_add subset_upperBounds_add
--/
 
-#print mul_mem_lowerBounds_mul /-
+/- warning: mul_mem_lower_bounds_mul -> mul_mem_lowerBounds_mul is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) a (lowerBounds.{u1} M _inst_2 s)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) b (lowerBounds.{u1} M _inst_2 t)) -> (Membership.Mem.{u1, u1} M (Set.{u1} M) (Set.hasMem.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1456 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1458 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1456 x._@.Mathlib.Algebra.Bounds._hyg.1458) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1471 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1473 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1471 x._@.Mathlib.Algebra.Bounds._hyg.1473)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1493 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1495 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1493 x._@.Mathlib.Algebra.Bounds._hyg.1495)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1508 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1510 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1508 x._@.Mathlib.Algebra.Bounds._hyg.1510)] {s : Set.{u1} M} {t : Set.{u1} M} {a : M} {b : M}, (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) a (lowerBounds.{u1} M _inst_2 s)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) b (lowerBounds.{u1} M _inst_2 t)) -> (Membership.mem.{u1, u1} M (Set.{u1} M) (Set.instMembershipSet.{u1} M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) a b) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t)))
+Case conversion may be inaccurate. Consider using '#align mul_mem_lower_bounds_mul mul_mem_lowerBounds_mulₓ'. -/
 @[to_additive]
 theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds s)
     (hb : b ∈ lowerBounds t) : a * b ∈ lowerBounds (s * t) :=
   @mul_mem_upperBounds_mul Mᵒᵈ _ _ _ _ _ _ _ _ ha hb
 #align mul_mem_lower_bounds_mul mul_mem_lowerBounds_mul
 #align add_mem_lower_bounds_add add_mem_lowerBounds_add
--/
 
-#print subset_lowerBounds_mul /-
+/- warning: subset_lower_bounds_mul -> subset_lowerBounds_mul is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (lowerBounds.{u1} M _inst_2 s) (lowerBounds.{u1} M _inst_2 t)) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1582 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1584 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1582 x._@.Mathlib.Algebra.Bounds._hyg.1584) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1597 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1599 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1597 x._@.Mathlib.Algebra.Bounds._hyg.1599)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1619 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1621 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1619 x._@.Mathlib.Algebra.Bounds._hyg.1621)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1634 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1636 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1634 x._@.Mathlib.Algebra.Bounds._hyg.1636)] (s : Set.{u1} M) (t : Set.{u1} M), 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 _inst_1)) (lowerBounds.{u1} M _inst_2 s) (lowerBounds.{u1} M _inst_2 t)) (lowerBounds.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+Case conversion may be inaccurate. Consider using '#align subset_lower_bounds_mul subset_lowerBounds_mulₓ'. -/
 @[to_additive]
 theorem subset_lowerBounds_mul (s t : Set M) :
     lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t) :=
   @subset_upperBounds_mul Mᵒᵈ _ _ _ _ _ _
 #align subset_lower_bounds_mul subset_lowerBounds_mul
 #align subset_lower_bounds_add subset_lowerBounds_add
--/
 
-#print BddAbove.mul /-
+/- warning: bdd_above.mul -> BddAbove.mul is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M}, (BddAbove.{u1} M _inst_2 s) -> (BddAbove.{u1} M _inst_2 t) -> (BddAbove.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1695 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1697 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1695 x._@.Mathlib.Algebra.Bounds._hyg.1697) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1710 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1712 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1710 x._@.Mathlib.Algebra.Bounds._hyg.1712)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1732 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1734 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1732 x._@.Mathlib.Algebra.Bounds._hyg.1734)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1747 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1749 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1747 x._@.Mathlib.Algebra.Bounds._hyg.1749)] {s : Set.{u1} M} {t : Set.{u1} M}, (BddAbove.{u1} M _inst_2 s) -> (BddAbove.{u1} M _inst_2 t) -> (BddAbove.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+Case conversion may be inaccurate. Consider using '#align bdd_above.mul BddAbove.mulₓ'. -/
 @[to_additive]
 theorem BddAbove.mul {s t : Set M} (hs : BddAbove s) (ht : BddAbove t) : BddAbove (s * t) :=
   (hs.mul ht).mono (subset_upperBounds_mul s t)
 #align bdd_above.mul BddAbove.mul
 #align bdd_above.add BddAbove.add
--/
 
-#print BddBelow.mul /-
+/- warning: bdd_below.mul -> BddBelow.mul is a dubious translation:
+lean 3 declaration is
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1)) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1))) (LE.le.{u1} M (Preorder.toHasLe.{u1} M _inst_2))] {s : Set.{u1} M} {t : Set.{u1} M}, (BddBelow.{u1} M _inst_2 s) -> (BddBelow.{u1} M _inst_2 t) -> (BddBelow.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+but is expected to have type
+  forall {M : Type.{u1}} [_inst_1 : Mul.{u1} M] [_inst_2 : Preorder.{u1} M] [_inst_3 : CovariantClass.{u1, u1} M M (fun (x._@.Mathlib.Algebra.Bounds._hyg.1807 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1809 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1807 x._@.Mathlib.Algebra.Bounds._hyg.1809) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1822 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1824 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1822 x._@.Mathlib.Algebra.Bounds._hyg.1824)] [_inst_4 : CovariantClass.{u1, u1} M M (Function.swap.{succ u1, succ u1, succ u1} M M (fun (ᾰ : M) (ᾰ : M) => M) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1844 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1846 : M) => HMul.hMul.{u1, u1, u1} M M M (instHMul.{u1} M _inst_1) x._@.Mathlib.Algebra.Bounds._hyg.1844 x._@.Mathlib.Algebra.Bounds._hyg.1846)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1859 : M) (x._@.Mathlib.Algebra.Bounds._hyg.1861 : M) => LE.le.{u1} M (Preorder.toLE.{u1} M _inst_2) x._@.Mathlib.Algebra.Bounds._hyg.1859 x._@.Mathlib.Algebra.Bounds._hyg.1861)] {s : Set.{u1} M} {t : Set.{u1} M}, (BddBelow.{u1} M _inst_2 s) -> (BddBelow.{u1} M _inst_2 t) -> (BddBelow.{u1} M _inst_2 (HMul.hMul.{u1, u1, u1} (Set.{u1} M) (Set.{u1} M) (Set.{u1} M) (instHMul.{u1} (Set.{u1} M) (Set.mul.{u1} M _inst_1)) s t))
+Case conversion may be inaccurate. Consider using '#align bdd_below.mul BddBelow.mulₓ'. -/
 @[to_additive]
 theorem BddBelow.mul {s t : Set M} (hs : BddBelow s) (ht : BddBelow t) : BddBelow (s * t) :=
   (hs.mul ht).mono (subset_lowerBounds_mul s t)
 #align bdd_below.mul BddBelow.mul
 #align bdd_below.add BddBelow.add
--/
 
 end mul_add
 
@@ -224,7 +248,7 @@ variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
 
 /- warning: csupr_mul -> ciSup_mul is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toHasLe.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
 but is expected to have type
   forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1982 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1984 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1982 x._@.Mathlib.Algebra.Bounds._hyg.1984)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1997 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1999 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.1997 x._@.Mathlib.Algebra.Bounds._hyg.1999)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
 Case conversion may be inaccurate. Consider using '#align csupr_mul ciSup_mulₓ'. -/
@@ -236,7 +260,7 @@ theorem ciSup_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆
 
 /- warning: csupr_div -> ciSup_div is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toHasLe.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
 but is expected to have type
   forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2087 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2089 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2087 x._@.Mathlib.Algebra.Bounds._hyg.2089)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2102 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2104 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2102 x._@.Mathlib.Algebra.Bounds._hyg.2104)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
 Case conversion may be inaccurate. Consider using '#align csupr_div ciSup_divₓ'. -/
@@ -255,7 +279,7 @@ variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
 
 /- warning: mul_csupr -> mul_ciSup is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))))) (LE.le.{u2} G (Preorder.toHasLe.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
 but is expected to have type
   forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.2247 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2249 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2247 x._@.Mathlib.Algebra.Bounds._hyg.2249) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2262 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2264 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2262 x._@.Mathlib.Algebra.Bounds._hyg.2264)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
 Case conversion may be inaccurate. Consider using '#align mul_csupr mul_ciSupₓ'. -/

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

@@ -222,29 +222,29 @@ section Right
 variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (Function.swap (· * ·)) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
-/- warning: csupr_mul -> csupᵢ_mul is a dubious translation:
+/- warning: csupr_mul -> ciSup_mul is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
 but is expected to have type
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1982 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1984 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1982 x._@.Mathlib.Algebra.Bounds._hyg.1984)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1997 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1999 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.1997 x._@.Mathlib.Algebra.Bounds._hyg.1999)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
-Case conversion may be inaccurate. Consider using '#align csupr_mul csupᵢ_mulₓ'. -/
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1982 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1984 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.1982 x._@.Mathlib.Algebra.Bounds._hyg.1984)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.1997 : G) (x._@.Mathlib.Algebra.Bounds._hyg.1999 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.1997 x._@.Mathlib.Algebra.Bounds._hyg.1999)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) (f i) a)))
+Case conversion may be inaccurate. Consider using '#align csupr_mul ciSup_mulₓ'. -/
 @[to_additive]
-theorem csupᵢ_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
-  (OrderIso.mulRight a).map_csupᵢ hf
-#align csupr_mul csupᵢ_mul
-#align csupr_add csupᵢ_add
+theorem ciSup_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
+  (OrderIso.mulRight a).map_ciSup hf
+#align csupr_mul ciSup_mul
+#align csupr_add ciSup_add
 
-/- warning: csupr_div -> csupᵢ_div is a dubious translation:
+/- warning: csupr_div -> ciSup_div is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toHasDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
 but is expected to have type
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2087 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2089 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2087 x._@.Mathlib.Algebra.Bounds._hyg.2089)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2102 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2104 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2102 x._@.Mathlib.Algebra.Bounds._hyg.2104)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
-Case conversion may be inaccurate. Consider using '#align csupr_div csupᵢ_divₓ'. -/
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (Function.swap.{succ u2, succ u2, succ u2} G G (fun (ᾰ : G) (ᾰ : G) => G) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2087 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2089 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2087 x._@.Mathlib.Algebra.Bounds._hyg.2089)) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2102 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2104 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2102 x._@.Mathlib.Algebra.Bounds._hyg.2104)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i)) a) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HDiv.hDiv.{u2, u2, u2} G G G (instHDiv.{u2} G (DivInvMonoid.toDiv.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))) (f i) a)))
+Case conversion may be inaccurate. Consider using '#align csupr_div ciSup_divₓ'. -/
 @[to_additive]
-theorem csupᵢ_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
-  simp only [div_eq_mul_inv, csupᵢ_mul hf]
-#align csupr_div csupᵢ_div
-#align csupr_sub csupᵢ_sub
+theorem ciSup_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
+  simp only [div_eq_mul_inv, ciSup_mul hf]
+#align csupr_div ciSup_div
+#align csupr_sub ciSup_sub
 
 end Right
 
@@ -253,17 +253,17 @@ section Left
 variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (· * ·) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
-/- warning: mul_csupr -> mul_csupᵢ is a dubious translation:
+/- warning: mul_csupr -> mul_ciSup is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i))) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1)))))) (LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))))] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => f i))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toHasSup.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toHasMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
 but is expected to have type
-  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.2247 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2249 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2247 x._@.Mathlib.Algebra.Bounds._hyg.2249) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2262 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2264 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2262 x._@.Mathlib.Algebra.Bounds._hyg.2264)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i))) (supᵢ.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
-Case conversion may be inaccurate. Consider using '#align mul_csupr mul_csupᵢₓ'. -/
+  forall {ι : Type.{u1}} {G : Type.{u2}} [_inst_1 : Group.{u2} G] [_inst_2 : ConditionallyCompleteLattice.{u2} G] [_inst_3 : CovariantClass.{u2, u2} G G (fun (x._@.Mathlib.Algebra.Bounds._hyg.2247 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2249 : G) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) x._@.Mathlib.Algebra.Bounds._hyg.2247 x._@.Mathlib.Algebra.Bounds._hyg.2249) (fun (x._@.Mathlib.Algebra.Bounds._hyg.2262 : G) (x._@.Mathlib.Algebra.Bounds._hyg.2264 : G) => LE.le.{u2} G (Preorder.toLE.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2))))) x._@.Mathlib.Algebra.Bounds._hyg.2262 x._@.Mathlib.Algebra.Bounds._hyg.2264)] [_inst_4 : Nonempty.{succ u1} ι] {f : ι -> G}, (BddAbove.{u2} G (PartialOrder.toPreorder.{u2} G (SemilatticeInf.toPartialOrder.{u2} G (Lattice.toSemilatticeInf.{u2} G (ConditionallyCompleteLattice.toLattice.{u2} G _inst_2)))) (Set.range.{u2, succ u1} G ι f)) -> (forall (a : G), Eq.{succ u2} G (HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => f i))) (iSup.{u2, succ u1} G (ConditionallyCompleteLattice.toSupSet.{u2} G _inst_2) ι (fun (i : ι) => HMul.hMul.{u2, u2, u2} G G G (instHMul.{u2} G (MulOneClass.toMul.{u2} G (Monoid.toMulOneClass.{u2} G (DivInvMonoid.toMonoid.{u2} G (Group.toDivInvMonoid.{u2} G _inst_1))))) a (f i))))
+Case conversion may be inaccurate. Consider using '#align mul_csupr mul_ciSupₓ'. -/
 @[to_additive]
-theorem mul_csupᵢ (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
-  (OrderIso.mulLeft a).map_csupᵢ hf
-#align mul_csupr mul_csupᵢ
-#align add_csupr add_csupᵢ
+theorem mul_ciSup (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
+  (OrderIso.mulLeft a).map_ciSup hf
+#align mul_csupr mul_ciSup
+#align add_csupr add_ciSup
 
 end Left
 

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

@@ -189,7 +189,7 @@ end Right
 
 section Left
 
-variable {ι G : Type*} [Group G] [ConditionallyCompleteLattice G]
+variable {ι : Sort*} {G : Type*} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (· * ·) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
 @[to_additive]

This PR adds some basic API lemmas for BddAbove (range f) (resp BddBelow). This is a ubiquitous side condition when working with iInf/iSup in conditionally complete lattices, so I think it's worth having.

Co-authored-by: Frédéric Dupuis <31101893+dupuisf@users.noreply.github.com>

@@ -88,6 +88,16 @@ theorem IsLUB.inv (h : IsLUB s a) : IsGLB s⁻¹ a⁻¹ :=
 #align is_lub.inv IsLUB.inv
 #align is_lub.neg IsLUB.neg
 
+@[to_additive]
+lemma BddBelow.range_inv {α : Type*} {f : α → G} (hf : BddBelow (range f)) :
+    BddAbove (range (fun x => (f x)⁻¹)) :=
+  hf.range_comp (OrderIso.inv G).monotone
+
+@[to_additive]
+lemma BddAbove.range_inv {α : Type*} {f : α → G} (hf : BddAbove (range f)) :
+    BddBelow (range (fun x => (f x)⁻¹)) :=
+  BddBelow.range_inv (G := Gᵒᵈ) hf
+
 end InvNeg
 
 section mul_add
@@ -135,6 +145,17 @@ theorem BddBelow.mul {s t : Set M} (hs : BddBelow s) (ht : BddBelow t) : BddBelo
 #align bdd_below.mul BddBelow.mul
 #align bdd_below.add BddBelow.add
 
+@[to_additive]
+lemma BddAbove.range_mul {α : Type*} {f g : α → M} (hf : BddAbove (range f))
+    (hg : BddAbove (range g)) : BddAbove (range (fun x => f x * g x)) :=
+  BddAbove.range_comp (f := fun x => (⟨f x, g x⟩ : M × M))
+    (bddAbove_range_prod.mpr ⟨hf, hg⟩) (Monotone.mul' monotone_fst monotone_snd)
+
+@[to_additive]
+lemma BddBelow.range_mul {α : Type*} {f g : α → M} (hf : BddBelow (range f))
+    (hg : BddBelow (range g)) : BddBelow (range (fun x => f x * g x)) :=
+  BddAbove.range_mul (M := Mᵒᵈ) hf hg
+
 end mul_add
 
 section ConditionallyCompleteLattice
@@ -145,23 +166,23 @@ variable {ι G : Type*} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (Function.swap (· * ·)) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
 @[to_additive]
-theorem ciSup_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
+theorem ciSup_mul (hf : BddAbove (range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
   (OrderIso.mulRight a).map_ciSup hf
 #align csupr_mul ciSup_mul
 #align csupr_add ciSup_add
 
 @[to_additive]
-theorem ciSup_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
+theorem ciSup_div (hf : BddAbove (range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
   simp only [div_eq_mul_inv, ciSup_mul hf]
 #align csupr_div ciSup_div
 #align csupr_sub ciSup_sub
 
 @[to_additive]
-theorem ciInf_mul (hf : BddBelow (Set.range f)) (a : G) : (⨅ i, f i) * a = ⨅ i, f i * a :=
+theorem ciInf_mul (hf : BddBelow (range f)) (a : G) : (⨅ i, f i) * a = ⨅ i, f i * a :=
   (OrderIso.mulRight a).map_ciInf hf
 
 @[to_additive]
-theorem ciInf_div (hf : BddBelow (Set.range f)) (a : G) : (⨅ i, f i) / a = ⨅ i, f i / a := by
+theorem ciInf_div (hf : BddBelow (range f)) (a : G) : (⨅ i, f i) / a = ⨅ i, f i / a := by
   simp only [div_eq_mul_inv, ciInf_mul hf]
 
 end Right
@@ -172,13 +193,13 @@ variable {ι G : Type*} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (· * ·) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
 @[to_additive]
-theorem mul_ciSup (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
+theorem mul_ciSup (hf : BddAbove (range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
   (OrderIso.mulLeft a).map_ciSup hf
 #align mul_csupr mul_ciSup
 #align add_csupr add_ciSup
 
 @[to_additive]
-theorem mul_ciInf (hf : BddBelow (Set.range f)) (a : G) : (a * ⨅ i, f i) = ⨅ i, a * f i :=
+theorem mul_ciInf (hf : BddBelow (range f)) (a : G) : (a * ⨅ i, f i) = ⨅ i, a * f i :=
   (OrderIso.mulLeft a).map_ciInf hf
 
 end Left

Using Lean4's named arguments, we manage to remove a few hard-to-read explicit function calls [@foo](https://github.com/foo) _ _ _ _ _ ... which used to be necessary in Lean3.

Occasionally, this results in slightly longer code. The benefit of named arguments is readability, as well as to reduce the brittleness of the code when the argument order is changed.

Co-authored-by: Michael Rothgang <rothgami@math.hu-berlin.de>

@@ -112,14 +112,14 @@ theorem subset_upperBounds_mul (s t : Set M) :
 @[to_additive]
 theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds s)
     (hb : b ∈ lowerBounds t) : a * b ∈ lowerBounds (s * t) :=
-  @mul_mem_upperBounds_mul Mᵒᵈ _ _ _ _ _ _ _ _ ha hb
+  mul_mem_upperBounds_mul (M := Mᵒᵈ) ha hb
 #align mul_mem_lower_bounds_mul mul_mem_lowerBounds_mul
 #align add_mem_lower_bounds_add add_mem_lowerBounds_add
 
 @[to_additive]
 theorem subset_lowerBounds_mul (s t : Set M) :
     lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t) :=
-  @subset_upperBounds_mul Mᵒᵈ _ _ _ _ _ _
+  subset_upperBounds_mul (M := Mᵒᵈ) _ _
 #align subset_lower_bounds_mul subset_lowerBounds_mul
 #align subset_lower_bounds_add subset_lowerBounds_add
 

@@ -156,6 +156,14 @@ theorem ciSup_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆
 #align csupr_div ciSup_div
 #align csupr_sub ciSup_sub
 
+@[to_additive]
+theorem ciInf_mul (hf : BddBelow (Set.range f)) (a : G) : (⨅ i, f i) * a = ⨅ i, f i * a :=
+  (OrderIso.mulRight a).map_ciInf hf
+
+@[to_additive]
+theorem ciInf_div (hf : BddBelow (Set.range f)) (a : G) : (⨅ i, f i) / a = ⨅ i, f i / a := by
+  simp only [div_eq_mul_inv, ciInf_mul hf]
+
 end Right
 
 section Left
@@ -169,6 +177,10 @@ theorem mul_ciSup (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆
 #align mul_csupr mul_ciSup
 #align add_csupr add_ciSup
 
+@[to_additive]
+theorem mul_ciInf (hf : BddBelow (Set.range f)) (a : G) : (a * ⨅ i, f i) = ⨅ i, a * f i :=
+  (OrderIso.mulLeft a).map_ciInf hf
+
 end Left
 
 end ConditionallyCompleteLattice

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

This has nice performance benefits.

@@ -25,7 +25,7 @@ open Pointwise
 
 section InvNeg
 
-variable {G : Type _} [Group G] [Preorder G] [CovariantClass G G (· * ·) (· ≤ ·)]
+variable {G : Type*} [Group G] [Preorder G] [CovariantClass G G (· * ·) (· ≤ ·)]
   [CovariantClass G G (swap (· * ·)) (· ≤ ·)] {s : Set G} {a : G}
 
 @[to_additive (attr := simp)]
@@ -92,7 +92,7 @@ end InvNeg
 
 section mul_add
 
-variable {M : Type _} [Mul M] [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)]
+variable {M : Type*} [Mul M] [Preorder M] [CovariantClass M M (· * ·) (· ≤ ·)]
   [CovariantClass M M (swap (· * ·)) (· ≤ ·)]
 
 @[to_additive]
@@ -141,7 +141,7 @@ section ConditionallyCompleteLattice
 
 section Right
 
-variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
+variable {ι G : Type*} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (Function.swap (· * ·)) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
 @[to_additive]
@@ -160,7 +160,7 @@ end Right
 
 section Left
 
-variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
+variable {ι G : Type*} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (· * ·) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
 @[to_additive]

• depends on: #5966

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

@@ -2,11 +2,6 @@
 Copyright (c) 2021 Yury G. Kudryashov. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yury G. Kudryashov
-
-! This file was ported from Lean 3 source module algebra.bounds
-! leanprover-community/mathlib commit dd71334db81d0bd444af1ee339a29298bef40734
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Group.OrderIso
 import Mathlib.Algebra.Order.Monoid.OrderDual
@@ -14,6 +9,8 @@ import Mathlib.Data.Set.Pointwise.Basic
 import Mathlib.Order.Bounds.OrderIso
 import Mathlib.Order.ConditionallyCompleteLattice.Basic
 
+#align_import algebra.bounds from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
+
 /-!
 # Upper/lower bounds in ordered monoids and groups
 

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>

@@ -148,16 +148,16 @@ variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (Function.swap (· * ·)) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
 @[to_additive]
-theorem csupᵢ_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
-  (OrderIso.mulRight a).map_csupᵢ hf
-#align csupr_mul csupᵢ_mul
-#align csupr_add csupᵢ_add
+theorem ciSup_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
+  (OrderIso.mulRight a).map_ciSup hf
+#align csupr_mul ciSup_mul
+#align csupr_add ciSup_add
 
 @[to_additive]
-theorem csupᵢ_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
-  simp only [div_eq_mul_inv, csupᵢ_mul hf]
-#align csupr_div csupᵢ_div
-#align csupr_sub csupᵢ_sub
+theorem ciSup_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
+  simp only [div_eq_mul_inv, ciSup_mul hf]
+#align csupr_div ciSup_div
+#align csupr_sub ciSup_sub
 
 end Right
 
@@ -167,10 +167,10 @@ variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
   [CovariantClass G G (· * ·) (· ≤ ·)] [Nonempty ι] {f : ι → G}
 
 @[to_additive]
-theorem mul_csupᵢ (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
-  (OrderIso.mulLeft a).map_csupᵢ hf
-#align mul_csupr mul_csupᵢ
-#align add_csupr add_csupᵢ
+theorem mul_ciSup (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
+  (OrderIso.mulLeft a).map_ciSup hf
+#align mul_csupr mul_ciSup
+#align add_csupr add_ciSup
 
 end Left
 

Also fix 1 name.

@@ -35,51 +35,61 @@ variable {G : Type _} [Group G] [Preorder G] [CovariantClass G G (· * ·) (· 
 theorem bddAbove_inv : BddAbove s⁻¹ ↔ BddBelow s :=
   (OrderIso.inv G).bddAbove_preimage
 #align bdd_above_inv bddAbove_inv
+#align bdd_above_neg bddAbove_neg
 
 @[to_additive (attr := simp)]
 theorem bddBelow_inv : BddBelow s⁻¹ ↔ BddAbove s :=
   (OrderIso.inv G).bddBelow_preimage
 #align bdd_below_inv bddBelow_inv
+#align bdd_below_neg bddBelow_neg
 
 @[to_additive]
 theorem BddAbove.inv (h : BddAbove s) : BddBelow s⁻¹ :=
   bddBelow_inv.2 h
 #align bdd_above.inv BddAbove.inv
+#align bdd_above.neg BddAbove.neg
 
 @[to_additive]
 theorem BddBelow.inv (h : BddBelow s) : BddAbove s⁻¹ :=
   bddAbove_inv.2 h
 #align bdd_below.inv BddBelow.inv
+#align bdd_below.neg BddBelow.neg
 
 @[to_additive (attr := simp)]
 theorem isLUB_inv : IsLUB s⁻¹ a ↔ IsGLB s a⁻¹ :=
   (OrderIso.inv G).isLUB_preimage
 #align is_lub_inv isLUB_inv
+#align is_lub_neg isLUB_neg
 
 @[to_additive]
 theorem isLUB_inv' : IsLUB s⁻¹ a⁻¹ ↔ IsGLB s a :=
   (OrderIso.inv G).isLUB_preimage'
 #align is_lub_inv' isLUB_inv'
+#align is_lub_neg' isLUB_neg'
 
 @[to_additive]
 theorem IsGLB.inv (h : IsGLB s a) : IsLUB s⁻¹ a⁻¹ :=
   isLUB_inv'.2 h
 #align is_glb.inv IsGLB.inv
+#align is_glb.neg IsGLB.neg
 
 @[to_additive (attr := simp)]
 theorem isGLB_inv : IsGLB s⁻¹ a ↔ IsLUB s a⁻¹ :=
   (OrderIso.inv G).isGLB_preimage
 #align is_glb_inv isGLB_inv
+#align is_glb_neg isGLB_neg
 
 @[to_additive]
 theorem isGLB_inv' : IsGLB s⁻¹ a⁻¹ ↔ IsLUB s a :=
   (OrderIso.inv G).isGLB_preimage'
 #align is_glb_inv' isGLB_inv'
+#align is_glb_neg' isGLB_neg'
 
 @[to_additive]
 theorem IsLUB.inv (h : IsLUB s a) : IsGLB s⁻¹ a⁻¹ :=
   isGLB_inv'.2 h
 #align is_lub.inv IsLUB.inv
+#align is_lub.neg IsLUB.neg
 
 end InvNeg
 
@@ -93,34 +103,40 @@ theorem mul_mem_upperBounds_mul {s t : Set M} {a b : M} (ha : a ∈ upperBounds
     (hb : b ∈ upperBounds t) : a * b ∈ upperBounds (s * t) :=
   forall_image2_iff.2 fun _ hx _ hy => mul_le_mul' (ha hx) (hb hy)
 #align mul_mem_upper_bounds_mul mul_mem_upperBounds_mul
+#align add_mem_upper_bounds_add add_mem_upperBounds_add
 
 @[to_additive]
 theorem subset_upperBounds_mul (s t : Set M) :
     upperBounds s * upperBounds t ⊆ upperBounds (s * t) :=
   image2_subset_iff.2 fun _ hx _ hy => mul_mem_upperBounds_mul hx hy
 #align subset_upper_bounds_mul subset_upperBounds_mul
+#align subset_upper_bounds_add subset_upperBounds_add
 
 @[to_additive]
 theorem mul_mem_lowerBounds_mul {s t : Set M} {a b : M} (ha : a ∈ lowerBounds s)
     (hb : b ∈ lowerBounds t) : a * b ∈ lowerBounds (s * t) :=
   @mul_mem_upperBounds_mul Mᵒᵈ _ _ _ _ _ _ _ _ ha hb
 #align mul_mem_lower_bounds_mul mul_mem_lowerBounds_mul
+#align add_mem_lower_bounds_add add_mem_lowerBounds_add
 
 @[to_additive]
 theorem subset_lowerBounds_mul (s t : Set M) :
     lowerBounds s * lowerBounds t ⊆ lowerBounds (s * t) :=
   @subset_upperBounds_mul Mᵒᵈ _ _ _ _ _ _
 #align subset_lower_bounds_mul subset_lowerBounds_mul
+#align subset_lower_bounds_add subset_lowerBounds_add
 
 @[to_additive]
 theorem BddAbove.mul {s t : Set M} (hs : BddAbove s) (ht : BddAbove t) : BddAbove (s * t) :=
   (Nonempty.mul hs ht).mono (subset_upperBounds_mul s t)
 #align bdd_above.mul BddAbove.mul
+#align bdd_above.add BddAbove.add
 
 @[to_additive]
 theorem BddBelow.mul {s t : Set M} (hs : BddBelow s) (ht : BddBelow t) : BddBelow (s * t) :=
   (Nonempty.mul hs ht).mono (subset_lowerBounds_mul s t)
 #align bdd_below.mul BddBelow.mul
+#align bdd_below.add BddBelow.add
 
 end mul_add
 
@@ -135,11 +151,13 @@ variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
 theorem csupᵢ_mul (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) * a = ⨆ i, f i * a :=
   (OrderIso.mulRight a).map_csupᵢ hf
 #align csupr_mul csupᵢ_mul
+#align csupr_add csupᵢ_add
 
 @[to_additive]
-theorem csupr_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
+theorem csupᵢ_div (hf : BddAbove (Set.range f)) (a : G) : (⨆ i, f i) / a = ⨆ i, f i / a := by
   simp only [div_eq_mul_inv, csupᵢ_mul hf]
-#align csupr_div csupr_div
+#align csupr_div csupᵢ_div
+#align csupr_sub csupᵢ_sub
 
 end Right
 
@@ -152,6 +170,7 @@ variable {ι G : Type _} [Group G] [ConditionallyCompleteLattice G]
 theorem mul_csupᵢ (hf : BddAbove (Set.range f)) (a : G) : (a * ⨆ i, f i) = ⨆ i, a * f i :=
   (OrderIso.mulLeft a).map_csupᵢ hf
 #align mul_csupr mul_csupᵢ
+#align add_csupr add_csupᵢ
 
 end Left
 

• depends on: #1188

Co-authored-by: ChrisHughes24 <chrishughes24@gmail.com> Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com> Co-authored-by: Johan Commelin <johan@commelin.net>