algebra.order.group.defs | Mathlib porting status

(last sync)

chore(algebra/order/group/defs): remove some instances that cause timeouts with etaExperiment (#18985)

Seeing what CI thinks about removing these instances.

This is a backport of https://github.com/leanprover-community/mathlib4/pull/3905

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

Diff

@@ -55,15 +55,19 @@ instance ordered_comm_group.to_ordered_cancel_comm_monoid [ordered_comm_group α
 example (α : Type u) [ordered_add_comm_group α] : covariant_class α α (swap (+)) (<) :=
 add_right_cancel_semigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
 
+-- Backporting note: this instance is not used,
+-- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
-instance ordered_comm_group.to_contravariant_class_left_le (α : Type u) [ordered_comm_group α] :
+theorem ordered_comm_group.to_contravariant_class_left_le (α : Type u) [ordered_comm_group α] :
   contravariant_class α α (*) (≤) :=
 { elim := λ a b c bc, by simpa using mul_le_mul_left' bc a⁻¹, }
 
+-- Backporting note: this instance is not used,
+-- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
-instance ordered_comm_group.to_contravariant_class_right_le (α : Type u) [ordered_comm_group α] :
+theorem ordered_comm_group.to_contravariant_class_right_le (α : Type u) [ordered_comm_group α] :
   contravariant_class α α (swap (*)) (≤) :=
 { elim := λ a b c bc, by simpa using mul_le_mul_right' bc a⁻¹, }

(no changes)

55bbb807

chore(algebra/order/group): Restore basic instances (#17810)

Moving the inheritance instances results in unexpected and confusing errors when importing algebra.order.group.defs but not algebra.order.group.instances. This puts the inheritance instances back into algebra.order.group.defs.

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
 import order.hom.basic
 import algebra.order.sub.defs
-import algebra.order.monoid.defs
+import algebra.order.monoid.cancel.defs
 
 /-!
 # Ordered groups
@@ -47,6 +47,12 @@ instance ordered_comm_group.to_covariant_class_left_le (α : Type u) [ordered_co
   covariant_class α α (*) (≤) :=
 { elim := λ a b c bc, ordered_comm_group.mul_le_mul_left b c bc a }
 
+@[priority 100, to_additive] -- See note [lower instance priority]
+instance ordered_comm_group.to_ordered_cancel_comm_monoid [ordered_comm_group α] :
+  ordered_cancel_comm_monoid α :=
+{ le_of_mul_le_mul_left := λ a b c, le_of_mul_le_mul_left',
+  ..‹ordered_comm_group α› }
+
 example (α : Type u) [ordered_add_comm_group α] : covariant_class α α (swap (+)) (<) :=
 add_right_cancel_semigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
 
@@ -807,6 +813,11 @@ instance linear_ordered_comm_group.to_no_min_order [nontrivial α] : no_min_orde
     exact λ a, ⟨a / y, (div_lt_self_iff a).mpr hy⟩
   end ⟩
 
+@[priority 100, to_additive] -- See note [lower instance priority]
+instance linear_ordered_comm_group.to_linear_ordered_cancel_comm_monoid :
+  linear_ordered_cancel_comm_monoid α :=
+{ ..‹linear_ordered_comm_group α›, ..ordered_comm_group.to_ordered_cancel_comm_monoid }
+
 end linear_ordered_comm_group
 
 namespace add_comm_group

f1a2caaf

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -1177,7 +1177,7 @@ variable [Group α] [LinearOrder α]
 #print cmp_div_one' /-
 @[simp, to_additive cmp_sub_zero]
 theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
-    cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel']
+    cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel]
 #align cmp_div_one' cmp_div_one'
 #align cmp_sub_zero cmp_sub_zero
 -/

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,9 +3,9 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathbin.Order.Hom.Basic
-import Mathbin.Algebra.Order.Sub.Defs
-import Mathbin.Algebra.Order.Monoid.Cancel.Defs
+import Order.Hom.Basic
+import Algebra.Order.Sub.Defs
+import Algebra.Order.Monoid.Cancel.Defs
 
 #align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -412,7 +412,7 @@ theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
 #align neg_le_neg_iff neg_le_neg_iff
 -/
 
-alias neg_le_neg_iff ↔ le_of_neg_le_neg _
+alias ⟨le_of_neg_le_neg, _⟩ := neg_le_neg_iff
 #align le_of_neg_le_neg le_of_neg_le_neg
 
 #print mul_inv_le_inv_mul_iff /-
@@ -438,7 +438,7 @@ theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by simp [
 #align le_sub_self_iff le_sub_self_iff
 -/
 
-alias sub_le_self_iff ↔ _ sub_le_self
+alias ⟨_, sub_le_self⟩ := sub_le_self_iff
 #align sub_le_self sub_le_self
 
 end TypeclassesLeftRightLe
@@ -470,12 +470,12 @@ theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ := by rw [← inv_lt_inv_iff, inv_in
 #align lt_neg lt_neg
 -/
 
-alias lt_inv' ↔ lt_inv_of_lt_inv _
+alias ⟨lt_inv_of_lt_inv, _⟩ := lt_inv'
 #align lt_inv_of_lt_inv lt_inv_of_lt_inv
 
 attribute [to_additive] lt_inv_of_lt_inv
 
-alias inv_lt' ↔ inv_lt_of_inv_lt' _
+alias ⟨inv_lt_of_inv_lt', _⟩ := inv_lt'
 #align inv_lt_of_inv_lt' inv_lt_of_inv_lt'
 
 attribute [to_additive neg_lt_of_neg_lt] inv_lt_of_inv_lt'
@@ -496,7 +496,7 @@ theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by simp [div_
 #align sub_lt_self_iff sub_lt_self_iff
 -/
 
-alias sub_lt_self_iff ↔ _ sub_lt_self
+alias ⟨_, sub_lt_self⟩ := sub_lt_self_iff
 #align sub_lt_self sub_lt_self
 
 end TypeclassesLeftRightLt
@@ -517,7 +517,7 @@ theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
 #align left.neg_le_self Left.neg_le_self
 -/
 
-alias Left.neg_le_self ← neg_le_self
+alias neg_le_self := Left.neg_le_self
 #align neg_le_self neg_le_self
 
 #print Left.self_le_inv /-
@@ -542,7 +542,7 @@ theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
 #align left.neg_lt_self Left.neg_lt_self
 -/
 
-alias Left.neg_lt_self ← neg_lt_self
+alias neg_lt_self := Left.neg_lt_self
 #align neg_lt_self neg_lt_self
 
 #print Left.self_lt_inv /-
@@ -667,72 +667,72 @@ end LT
 
 end CommGroup
 
-alias Left.inv_le_one_iff ↔ one_le_of_inv_le_one _
+alias ⟨one_le_of_inv_le_one, _⟩ := Left.inv_le_one_iff
 #align one_le_of_inv_le_one one_le_of_inv_le_one
 
 attribute [to_additive] one_le_of_inv_le_one
 
-alias Left.one_le_inv_iff ↔ le_one_of_one_le_inv _
+alias ⟨le_one_of_one_le_inv, _⟩ := Left.one_le_inv_iff
 #align le_one_of_one_le_inv le_one_of_one_le_inv
 
 attribute [to_additive nonpos_of_neg_nonneg] le_one_of_one_le_inv
 
-alias inv_lt_inv_iff ↔ lt_of_inv_lt_inv _
+alias ⟨lt_of_inv_lt_inv, _⟩ := inv_lt_inv_iff
 #align lt_of_inv_lt_inv lt_of_inv_lt_inv
 
 attribute [to_additive] lt_of_inv_lt_inv
 
-alias Left.inv_lt_one_iff ↔ one_lt_of_inv_lt_one _
+alias ⟨one_lt_of_inv_lt_one, _⟩ := Left.inv_lt_one_iff
 #align one_lt_of_inv_lt_one one_lt_of_inv_lt_one
 
 attribute [to_additive] one_lt_of_inv_lt_one
 
-alias Left.inv_lt_one_iff ← inv_lt_one_iff_one_lt
+alias inv_lt_one_iff_one_lt := Left.inv_lt_one_iff
 #align inv_lt_one_iff_one_lt inv_lt_one_iff_one_lt
 
 attribute [to_additive] inv_lt_one_iff_one_lt
 
-alias Left.inv_lt_one_iff ← inv_lt_one'
+alias inv_lt_one' := Left.inv_lt_one_iff
 #align inv_lt_one' inv_lt_one'
 
 attribute [to_additive neg_lt_zero] inv_lt_one'
 
-alias Left.one_lt_inv_iff ↔ inv_of_one_lt_inv _
+alias ⟨inv_of_one_lt_inv, _⟩ := Left.one_lt_inv_iff
 #align inv_of_one_lt_inv inv_of_one_lt_inv
 
 attribute [to_additive neg_of_neg_pos] inv_of_one_lt_inv
 
-alias Left.one_lt_inv_iff ↔ _ one_lt_inv_of_inv
+alias ⟨_, one_lt_inv_of_inv⟩ := Left.one_lt_inv_iff
 #align one_lt_inv_of_inv one_lt_inv_of_inv
 
 attribute [to_additive neg_pos_of_neg] one_lt_inv_of_inv
 
-alias le_inv_mul_iff_mul_le ↔ mul_le_of_le_inv_mul _
+alias ⟨mul_le_of_le_inv_mul, _⟩ := le_inv_mul_iff_mul_le
 #align mul_le_of_le_inv_mul mul_le_of_le_inv_mul
 
 attribute [to_additive] mul_le_of_le_inv_mul
 
-alias le_inv_mul_iff_mul_le ↔ _ le_inv_mul_of_mul_le
+alias ⟨_, le_inv_mul_of_mul_le⟩ := le_inv_mul_iff_mul_le
 #align le_inv_mul_of_mul_le le_inv_mul_of_mul_le
 
 attribute [to_additive] le_inv_mul_of_mul_le
 
-alias inv_mul_le_iff_le_mul ↔ _ inv_mul_le_of_le_mul
+alias ⟨_, inv_mul_le_of_le_mul⟩ := inv_mul_le_iff_le_mul
 #align inv_mul_le_of_le_mul inv_mul_le_of_le_mul
 
 attribute [to_additive] inv_mul_le_iff_le_mul
 
-alias lt_inv_mul_iff_mul_lt ↔ mul_lt_of_lt_inv_mul _
+alias ⟨mul_lt_of_lt_inv_mul, _⟩ := lt_inv_mul_iff_mul_lt
 #align mul_lt_of_lt_inv_mul mul_lt_of_lt_inv_mul
 
 attribute [to_additive] mul_lt_of_lt_inv_mul
 
-alias lt_inv_mul_iff_mul_lt ↔ _ lt_inv_mul_of_mul_lt
+alias ⟨_, lt_inv_mul_of_mul_lt⟩ := lt_inv_mul_iff_mul_lt
 #align lt_inv_mul_of_mul_lt lt_inv_mul_of_mul_lt
 
 attribute [to_additive] lt_inv_mul_of_mul_lt
 
-alias inv_mul_lt_iff_lt_mul ↔ lt_mul_of_inv_mul_lt inv_mul_lt_of_lt_mul
+alias ⟨lt_mul_of_inv_mul_lt, inv_mul_lt_of_lt_mul⟩ := inv_mul_lt_iff_lt_mul
 #align lt_mul_of_inv_mul_lt lt_mul_of_inv_mul_lt
 #align inv_mul_lt_of_lt_mul inv_mul_lt_of_lt_mul
 
@@ -740,38 +740,38 @@ attribute [to_additive] lt_mul_of_inv_mul_lt
 
 attribute [to_additive] inv_mul_lt_of_lt_mul
 
-alias lt_mul_of_inv_mul_lt ← lt_mul_of_inv_mul_lt_left
+alias lt_mul_of_inv_mul_lt_left := lt_mul_of_inv_mul_lt
 #align lt_mul_of_inv_mul_lt_left lt_mul_of_inv_mul_lt_left
 
 attribute [to_additive] lt_mul_of_inv_mul_lt_left
 
-alias Left.inv_le_one_iff ← inv_le_one'
+alias inv_le_one' := Left.inv_le_one_iff
 #align inv_le_one' inv_le_one'
 
 attribute [to_additive neg_nonpos] inv_le_one'
 
-alias Left.one_le_inv_iff ← one_le_inv'
+alias one_le_inv' := Left.one_le_inv_iff
 #align one_le_inv' one_le_inv'
 
 attribute [to_additive neg_nonneg] one_le_inv'
 
-alias Left.one_lt_inv_iff ← one_lt_inv'
+alias one_lt_inv' := Left.one_lt_inv_iff
 #align one_lt_inv' one_lt_inv'
 
 attribute [to_additive neg_pos] one_lt_inv'
 
-alias mul_lt_mul_left' ← OrderedCommGroup.mul_lt_mul_left'
+alias OrderedCommGroup.mul_lt_mul_left' := mul_lt_mul_left'
 #align ordered_comm_group.mul_lt_mul_left' OrderedCommGroup.mul_lt_mul_left'
 
 attribute [to_additive OrderedAddCommGroup.add_lt_add_left] OrderedCommGroup.mul_lt_mul_left'
 
-alias le_of_mul_le_mul_left' ← OrderedCommGroup.le_of_mul_le_mul_left
+alias OrderedCommGroup.le_of_mul_le_mul_left := le_of_mul_le_mul_left'
 #align ordered_comm_group.le_of_mul_le_mul_left OrderedCommGroup.le_of_mul_le_mul_left
 
 attribute [to_additive OrderedAddCommGroup.le_of_add_le_add_left]
   OrderedCommGroup.le_of_mul_le_mul_left
 
-alias lt_of_mul_lt_mul_left' ← OrderedCommGroup.lt_of_mul_lt_mul_left
+alias OrderedCommGroup.lt_of_mul_lt_mul_left := lt_of_mul_lt_mul_left'
 #align ordered_comm_group.lt_of_mul_lt_mul_left OrderedCommGroup.lt_of_mul_lt_mul_left
 
 attribute [to_additive OrderedAddCommGroup.lt_of_add_lt_add_left]
@@ -811,7 +811,7 @@ theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a := by
 #align sub_nonneg sub_nonneg
 -/
 
-alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
+alias ⟨le_of_sub_nonneg, sub_nonneg_of_le⟩ := sub_nonneg
 #align le_of_sub_nonneg le_of_sub_nonneg
 #align sub_nonneg_of_le sub_nonneg_of_le
 
@@ -823,7 +823,7 @@ theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
 #align sub_nonpos sub_nonpos
 -/
 
-alias sub_nonpos ↔ le_of_sub_nonpos sub_nonpos_of_le
+alias ⟨le_of_sub_nonpos, sub_nonpos_of_le⟩ := sub_nonpos
 #align le_of_sub_nonpos le_of_sub_nonpos
 #align sub_nonpos_of_le sub_nonpos_of_le
 
@@ -835,7 +835,7 @@ theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c := by
 #align le_sub_iff_add_le le_sub_iff_add_le
 -/
 
-alias le_sub_iff_add_le ↔ add_le_of_le_sub_right le_sub_right_of_add_le
+alias ⟨add_le_of_le_sub_right, le_sub_right_of_add_le⟩ := le_sub_iff_add_le
 #align add_le_of_le_sub_right add_le_of_le_sub_right
 #align le_sub_right_of_add_le le_sub_right_of_add_le
 
@@ -909,7 +909,7 @@ theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c := by rw [le_div_iff_mu
 #align le_sub_iff_add_le' le_sub_iff_add_le'
 -/
 
-alias le_sub_iff_add_le' ↔ add_le_of_le_sub_left le_sub_left_of_add_le
+alias ⟨add_le_of_le_sub_left, le_sub_left_of_add_le⟩ := le_sub_iff_add_le'
 #align add_le_of_le_sub_left add_le_of_le_sub_left
 #align le_sub_left_of_add_le le_sub_left_of_add_le
 
@@ -920,7 +920,7 @@ theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le
 #align sub_le_iff_le_add' sub_le_iff_le_add'
 -/
 
-alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
+alias ⟨le_add_of_sub_left_le, sub_left_le_of_le_add⟩ := sub_le_iff_le_add'
 #align le_add_of_sub_left_le le_add_of_sub_left_le
 #align sub_left_le_of_le_add sub_left_le_of_le_add
 
@@ -1009,7 +1009,7 @@ theorem one_lt_div' : 1 < a / b ↔ b < a := by
 #align sub_pos sub_pos
 -/
 
-alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
+alias ⟨lt_of_sub_pos, sub_pos_of_lt⟩ := sub_pos
 #align lt_of_sub_pos lt_of_sub_pos
 #align sub_pos_of_lt sub_pos_of_lt
 
@@ -1021,11 +1021,11 @@ theorem div_lt_one' : a / b < 1 ↔ a < b := by
 #align sub_neg sub_neg
 -/
 
-alias sub_neg ↔ lt_of_sub_neg sub_neg_of_lt
+alias ⟨lt_of_sub_neg, sub_neg_of_lt⟩ := sub_neg
 #align lt_of_sub_neg lt_of_sub_neg
 #align sub_neg_of_lt sub_neg_of_lt
 
-alias sub_neg ← sub_lt_zero
+alias sub_lt_zero := sub_neg
 #align sub_lt_zero sub_lt_zero
 
 #print lt_div_iff_mul_lt /-
@@ -1036,7 +1036,7 @@ theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c := by
 #align lt_sub_iff_add_lt lt_sub_iff_add_lt
 -/
 
-alias lt_sub_iff_add_lt ↔ add_lt_of_lt_sub_right lt_sub_right_of_add_lt
+alias ⟨add_lt_of_lt_sub_right, lt_sub_right_of_add_lt⟩ := lt_sub_iff_add_lt
 #align add_lt_of_lt_sub_right add_lt_of_lt_sub_right
 #align lt_sub_right_of_add_lt lt_sub_right_of_add_lt
 
@@ -1048,7 +1048,7 @@ theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c := by
 #align sub_lt_iff_lt_add sub_lt_iff_lt_add
 -/
 
-alias sub_lt_iff_lt_add ↔ lt_add_of_sub_right_lt sub_right_lt_of_lt_add
+alias ⟨lt_add_of_sub_right_lt, sub_right_lt_of_lt_add⟩ := sub_lt_iff_lt_add
 #align lt_add_of_sub_right_lt lt_add_of_sub_right_lt
 #align sub_right_lt_of_lt_add sub_right_lt_of_lt_add
 
@@ -1111,7 +1111,7 @@ theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c := by rw [lt_div_iff_mul_lt
 #align lt_sub_iff_add_lt' lt_sub_iff_add_lt'
 -/
 
-alias lt_sub_iff_add_lt' ↔ add_lt_of_lt_sub_left lt_sub_left_of_add_lt
+alias ⟨add_lt_of_lt_sub_left, lt_sub_left_of_add_lt⟩ := lt_sub_iff_add_lt'
 #align add_lt_of_lt_sub_left add_lt_of_lt_sub_left
 #align lt_sub_left_of_add_lt lt_sub_left_of_add_lt
 
@@ -1122,7 +1122,7 @@ theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c := by rw [div_lt_iff_lt_mul
 #align sub_lt_iff_lt_add' sub_lt_iff_lt_add'
 -/
 
-alias sub_lt_iff_lt_add' ↔ lt_add_of_sub_left_lt sub_left_lt_of_lt_add
+alias ⟨lt_add_of_sub_left_lt, sub_left_lt_of_lt_add⟩ := sub_lt_iff_lt_add'
 #align lt_add_of_sub_left_lt lt_add_of_sub_left_lt
 #align sub_left_lt_of_lt_add sub_left_lt_of_lt_add

bump to nightly-2023-08-17-09

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

60285dcc

Diff

@@ -55,7 +55,7 @@ attribute [to_additive] OrderedCommGroup
 @[to_additive]
 instance OrderedCommGroup.to_covariantClass_left_le (α : Type u) [OrderedCommGroup α] :
     CovariantClass α α (· * ·) (· ≤ ·)
-    where elim a b c bc := OrderedCommGroup.mul_le_mul_left b c bc a
+    where elim a b c bc := OrderedCommGroup.hMul_le_hMul_left b c bc a
 #align ordered_comm_group.to_covariant_class_left_le OrderedCommGroup.to_covariantClass_left_le
 #align ordered_add_comm_group.to_covariant_class_left_le OrderedAddCommGroup.to_covariantClass_left_le
 -/

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-
-! This file was ported from Lean 3 source module algebra.order.group.defs
-! leanprover-community/mathlib commit b599f4e4e5cf1fbcb4194503671d3d9e569c1fce
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Hom.Basic
 import Mathbin.Algebra.Order.Sub.Defs
 import Mathbin.Algebra.Order.Monoid.Cancel.Defs
 
+#align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"
+
 /-!
 # Ordered groups

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -54,12 +54,14 @@ class OrderedCommGroup (α : Type u) extends CommGroup α, PartialOrder α where
 
 attribute [to_additive] OrderedCommGroup
 
+#print OrderedCommGroup.to_covariantClass_left_le /-
 @[to_additive]
 instance OrderedCommGroup.to_covariantClass_left_le (α : Type u) [OrderedCommGroup α] :
     CovariantClass α α (· * ·) (· ≤ ·)
     where elim a b c bc := OrderedCommGroup.mul_le_mul_left b c bc a
 #align ordered_comm_group.to_covariant_class_left_le OrderedCommGroup.to_covariantClass_left_le
 #align ordered_add_comm_group.to_covariant_class_left_le OrderedAddCommGroup.to_covariantClass_left_le
+-/
 
 #print OrderedCommGroup.toOrderedCancelCommMonoid /-
 -- See note [lower instance priority]
@@ -74,6 +76,7 @@ instance (priority := 100) OrderedCommGroup.toOrderedCancelCommMonoid [OrderedCo
 example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (· + ·)) (· < ·) :=
   AddRightCancelSemigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
 
+#print OrderedCommGroup.to_contravariantClass_left_le /-
 -- Backporting note: this instance is not used,
 -- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
@@ -83,7 +86,9 @@ theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCom
   { elim := fun a b c bc => by simpa using mul_le_mul_left' bc a⁻¹ }
 #align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
 #align ordered_add_comm_group.to_contravariant_class_left_le OrderedAddCommGroup.to_contravariantClass_left_le
+-/
 
+#print OrderedCommGroup.to_contravariantClass_right_le /-
 -- Backporting note: this instance is not used,
 -- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
@@ -93,6 +98,7 @@ theorem OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedCo
   { elim := fun a b c bc => by simpa using mul_le_mul_right' bc a⁻¹ }
 #align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_le
 #align ordered_add_comm_group.to_contravariant_class_right_le OrderedAddCommGroup.to_contravariantClass_right_le
+-/
 
 section Group
 
@@ -102,52 +108,68 @@ section TypeclassesLeftLe
 
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
+#print Left.inv_le_one_iff /-
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.neg_nonpos_iff "Uses `left` co(ntra)variant."]
 theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by rw [← mul_le_mul_iff_left a]; simp
 #align left.inv_le_one_iff Left.inv_le_one_iff
 #align left.neg_nonpos_iff Left.neg_nonpos_iff
+-/
 
+#print Left.one_le_inv_iff /-
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.nonneg_neg_iff "Uses `left` co(ntra)variant."]
 theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by rw [← mul_le_mul_iff_left a]; simp
 #align left.one_le_inv_iff Left.one_le_inv_iff
 #align left.nonneg_neg_iff Left.nonneg_neg_iff
+-/
 
+#print le_inv_mul_iff_mul_le /-
 @[simp, to_additive]
 theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c := by rw [← mul_le_mul_iff_left a]; simp
 #align le_inv_mul_iff_mul_le le_inv_mul_iff_mul_le
 #align le_neg_add_iff_add_le le_neg_add_iff_add_le
+-/
 
+#print inv_mul_le_iff_le_mul /-
 @[simp, to_additive]
 theorem inv_mul_le_iff_le_mul : b⁻¹ * a ≤ c ↔ a ≤ b * c := by
   rw [← mul_le_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_le_iff_le_mul inv_mul_le_iff_le_mul
 #align neg_add_le_iff_le_add neg_add_le_iff_le_add
+-/
 
+#print inv_le_iff_one_le_mul' /-
 @[to_additive neg_le_iff_add_nonneg']
 theorem inv_le_iff_one_le_mul' : a⁻¹ ≤ b ↔ 1 ≤ a * b :=
   (mul_le_mul_iff_left a).symm.trans <| by rw [mul_inv_self]
 #align inv_le_iff_one_le_mul' inv_le_iff_one_le_mul'
 #align neg_le_iff_add_nonneg' neg_le_iff_add_nonneg'
+-/
 
+#print le_inv_iff_mul_le_one_left /-
 @[to_additive]
 theorem le_inv_iff_mul_le_one_left : a ≤ b⁻¹ ↔ b * a ≤ 1 :=
   (mul_le_mul_iff_left b).symm.trans <| by rw [mul_inv_self]
 #align le_inv_iff_mul_le_one_left le_inv_iff_mul_le_one_left
 #align le_neg_iff_add_nonpos_left le_neg_iff_add_nonpos_left
+-/
 
+#print le_inv_mul_iff_le /-
 @[to_additive]
 theorem le_inv_mul_iff_le : 1 ≤ b⁻¹ * a ↔ b ≤ a := by
   rw [← mul_le_mul_iff_left b, mul_one, mul_inv_cancel_left]
 #align le_inv_mul_iff_le le_inv_mul_iff_le
 #align le_neg_add_iff_le le_neg_add_iff_le
+-/
 
+#print inv_mul_le_one_iff /-
 @[to_additive]
 theorem inv_mul_le_one_iff : a⁻¹ * b ≤ 1 ↔ b ≤ a :=
   trans inv_mul_le_iff_le_mul <| by rw [mul_one]
 #align inv_mul_le_one_iff inv_mul_le_one_iff
 #align neg_add_nonpos_iff neg_add_nonpos_iff
+-/
 
 end TypeclassesLeftLe
 
@@ -155,54 +177,70 @@ section TypeclassesLeftLt
 
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c : α}
 
+#print Left.one_lt_inv_iff /-
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.neg_pos_iff "Uses `left` co(ntra)variant."]
 theorem Left.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
   rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
 #align left.one_lt_inv_iff Left.one_lt_inv_iff
 #align left.neg_pos_iff Left.neg_pos_iff
+-/
 
+#print Left.inv_lt_one_iff /-
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.neg_neg_iff "Uses `left` co(ntra)variant."]
 theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
   rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
 #align left.inv_lt_one_iff Left.inv_lt_one_iff
 #align left.neg_neg_iff Left.neg_neg_iff
+-/
 
+#print lt_inv_mul_iff_mul_lt /-
 @[simp, to_additive]
 theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c := by rw [← mul_lt_mul_iff_left a]; simp
 #align lt_inv_mul_iff_mul_lt lt_inv_mul_iff_mul_lt
 #align lt_neg_add_iff_add_lt lt_neg_add_iff_add_lt
+-/
 
+#print inv_mul_lt_iff_lt_mul /-
 @[simp, to_additive]
 theorem inv_mul_lt_iff_lt_mul : b⁻¹ * a < c ↔ a < b * c := by
   rw [← mul_lt_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_lt_iff_lt_mul inv_mul_lt_iff_lt_mul
 #align neg_add_lt_iff_lt_add neg_add_lt_iff_lt_add
+-/
 
+#print inv_lt_iff_one_lt_mul' /-
 @[to_additive]
 theorem inv_lt_iff_one_lt_mul' : a⁻¹ < b ↔ 1 < a * b :=
   (mul_lt_mul_iff_left a).symm.trans <| by rw [mul_inv_self]
 #align inv_lt_iff_one_lt_mul' inv_lt_iff_one_lt_mul'
 #align neg_lt_iff_pos_add' neg_lt_iff_pos_add'
+-/
 
+#print lt_inv_iff_mul_lt_one' /-
 @[to_additive]
 theorem lt_inv_iff_mul_lt_one' : a < b⁻¹ ↔ b * a < 1 :=
   (mul_lt_mul_iff_left b).symm.trans <| by rw [mul_inv_self]
 #align lt_inv_iff_mul_lt_one' lt_inv_iff_mul_lt_one'
 #align lt_neg_iff_add_neg' lt_neg_iff_add_neg'
+-/
 
+#print lt_inv_mul_iff_lt /-
 @[to_additive]
 theorem lt_inv_mul_iff_lt : 1 < b⁻¹ * a ↔ b < a := by
   rw [← mul_lt_mul_iff_left b, mul_one, mul_inv_cancel_left]
 #align lt_inv_mul_iff_lt lt_inv_mul_iff_lt
 #align lt_neg_add_iff_lt lt_neg_add_iff_lt
+-/
 
+#print inv_mul_lt_one_iff /-
 @[to_additive]
 theorem inv_mul_lt_one_iff : a⁻¹ * b < 1 ↔ b < a :=
   trans inv_mul_lt_iff_lt_mul <| by rw [mul_one]
 #align inv_mul_lt_one_iff inv_mul_lt_one_iff
 #align neg_add_neg_iff neg_add_neg_iff
+-/
 
 end TypeclassesLeftLt
 
@@ -210,59 +248,77 @@ section TypeclassesRightLe
 
 variable [LE α] [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
+#print Right.inv_le_one_iff /-
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.neg_nonpos_iff "Uses `right` co(ntra)variant."]
 theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by rw [← mul_le_mul_iff_right a]; simp
 #align right.inv_le_one_iff Right.inv_le_one_iff
 #align right.neg_nonpos_iff Right.neg_nonpos_iff
+-/
 
+#print Right.one_le_inv_iff /-
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.nonneg_neg_iff "Uses `right` co(ntra)variant."]
 theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by rw [← mul_le_mul_iff_right a]; simp
 #align right.one_le_inv_iff Right.one_le_inv_iff
 #align right.nonneg_neg_iff Right.nonneg_neg_iff
+-/
 
+#print inv_le_iff_one_le_mul /-
 @[to_additive neg_le_iff_add_nonneg]
 theorem inv_le_iff_one_le_mul : a⁻¹ ≤ b ↔ 1 ≤ b * a :=
   (mul_le_mul_iff_right a).symm.trans <| by rw [inv_mul_self]
 #align inv_le_iff_one_le_mul inv_le_iff_one_le_mul
 #align neg_le_iff_add_nonneg neg_le_iff_add_nonneg
+-/
 
+#print le_inv_iff_mul_le_one_right /-
 @[to_additive]
 theorem le_inv_iff_mul_le_one_right : a ≤ b⁻¹ ↔ a * b ≤ 1 :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align le_inv_iff_mul_le_one_right le_inv_iff_mul_le_one_right
 #align le_neg_iff_add_nonpos_right le_neg_iff_add_nonpos_right
+-/
 
+#print mul_inv_le_iff_le_mul /-
 @[simp, to_additive]
 theorem mul_inv_le_iff_le_mul : a * b⁻¹ ≤ c ↔ a ≤ c * b :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align mul_inv_le_iff_le_mul mul_inv_le_iff_le_mul
 #align add_neg_le_iff_le_add add_neg_le_iff_le_add
+-/
 
+#print le_mul_inv_iff_mul_le /-
 @[simp, to_additive]
 theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align le_mul_inv_iff_mul_le le_mul_inv_iff_mul_le
 #align le_add_neg_iff_add_le le_add_neg_iff_add_le
+-/
 
+#print mul_inv_le_one_iff_le /-
 @[simp, to_additive]
 theorem mul_inv_le_one_iff_le : a * b⁻¹ ≤ 1 ↔ a ≤ b :=
   mul_inv_le_iff_le_mul.trans <| by rw [one_mul]
 #align mul_inv_le_one_iff_le mul_inv_le_one_iff_le
 #align add_neg_nonpos_iff_le add_neg_nonpos_iff_le
+-/
 
+#print le_mul_inv_iff_le /-
 @[to_additive]
 theorem le_mul_inv_iff_le : 1 ≤ a * b⁻¹ ↔ b ≤ a := by
   rw [← mul_le_mul_iff_right b, one_mul, inv_mul_cancel_right]
 #align le_mul_inv_iff_le le_mul_inv_iff_le
 #align le_add_neg_iff_le le_add_neg_iff_le
+-/
 
+#print mul_inv_le_one_iff /-
 @[to_additive]
 theorem mul_inv_le_one_iff : b * a⁻¹ ≤ 1 ↔ b ≤ a :=
   trans mul_inv_le_iff_le_mul <| by rw [one_mul]
 #align mul_inv_le_one_iff mul_inv_le_one_iff
 #align add_neg_nonpos_iff add_neg_nonpos_iff
+-/
 
 end TypeclassesRightLe
 
@@ -270,61 +326,79 @@ section TypeclassesRightLt
 
 variable [LT α] [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c : α}
 
+#print Right.inv_lt_one_iff /-
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.neg_neg_iff "Uses `right` co(ntra)variant."]
 theorem Right.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
   rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
 #align right.inv_lt_one_iff Right.inv_lt_one_iff
 #align right.neg_neg_iff Right.neg_neg_iff
+-/
 
+#print Right.one_lt_inv_iff /-
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.neg_pos_iff "Uses `right` co(ntra)variant."]
 theorem Right.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
   rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
 #align right.one_lt_inv_iff Right.one_lt_inv_iff
 #align right.neg_pos_iff Right.neg_pos_iff
+-/
 
+#print inv_lt_iff_one_lt_mul /-
 @[to_additive]
 theorem inv_lt_iff_one_lt_mul : a⁻¹ < b ↔ 1 < b * a :=
   (mul_lt_mul_iff_right a).symm.trans <| by rw [inv_mul_self]
 #align inv_lt_iff_one_lt_mul inv_lt_iff_one_lt_mul
 #align neg_lt_iff_pos_add neg_lt_iff_pos_add
+-/
 
+#print lt_inv_iff_mul_lt_one /-
 @[to_additive]
 theorem lt_inv_iff_mul_lt_one : a < b⁻¹ ↔ a * b < 1 :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align lt_inv_iff_mul_lt_one lt_inv_iff_mul_lt_one
 #align lt_neg_iff_add_neg lt_neg_iff_add_neg
+-/
 
+#print mul_inv_lt_iff_lt_mul /-
 @[simp, to_additive]
 theorem mul_inv_lt_iff_lt_mul : a * b⁻¹ < c ↔ a < c * b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right]
 #align mul_inv_lt_iff_lt_mul mul_inv_lt_iff_lt_mul
 #align add_neg_lt_iff_lt_add add_neg_lt_iff_lt_add
+-/
 
+#print lt_mul_inv_iff_mul_lt /-
 @[simp, to_additive]
 theorem lt_mul_inv_iff_mul_lt : c < a * b⁻¹ ↔ c * b < a :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align lt_mul_inv_iff_mul_lt lt_mul_inv_iff_mul_lt
 #align lt_add_neg_iff_add_lt lt_add_neg_iff_add_lt
+-/
 
+#print inv_mul_lt_one_iff_lt /-
 @[simp, to_additive]
 theorem inv_mul_lt_one_iff_lt : a * b⁻¹ < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right, one_mul]
 #align inv_mul_lt_one_iff_lt inv_mul_lt_one_iff_lt
 #align neg_add_neg_iff_lt neg_add_neg_iff_lt
+-/
 
+#print lt_mul_inv_iff_lt /-
 @[to_additive]
 theorem lt_mul_inv_iff_lt : 1 < a * b⁻¹ ↔ b < a := by
   rw [← mul_lt_mul_iff_right b, one_mul, inv_mul_cancel_right]
 #align lt_mul_inv_iff_lt lt_mul_inv_iff_lt
 #align lt_add_neg_iff_lt lt_add_neg_iff_lt
+-/
 
+#print mul_inv_lt_one_iff /-
 @[to_additive]
 theorem mul_inv_lt_one_iff : b * a⁻¹ < 1 ↔ b < a :=
   trans mul_inv_lt_iff_lt_mul <| by rw [one_mul]
 #align mul_inv_lt_one_iff mul_inv_lt_one_iff
 #align add_neg_neg_iff add_neg_neg_iff
+-/
 
 end TypeclassesRightLt
 
@@ -333,31 +407,39 @@ section TypeclassesLeftRightLe
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] [CovariantClass α α (swap (· * ·)) (· ≤ ·)]
   {a b c d : α}
 
+#print inv_le_inv_iff /-
 @[simp, to_additive]
 theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
   rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]; simp
 #align inv_le_inv_iff inv_le_inv_iff
 #align neg_le_neg_iff neg_le_neg_iff
+-/
 
 alias neg_le_neg_iff ↔ le_of_neg_le_neg _
 #align le_of_neg_le_neg le_of_neg_le_neg
 
+#print mul_inv_le_inv_mul_iff /-
 @[to_additive]
 theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b := by
   rw [← mul_le_mul_iff_left d, ← mul_le_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
     inv_mul_cancel_right]
 #align mul_inv_le_inv_mul_iff mul_inv_le_inv_mul_iff
 #align add_neg_le_neg_add_iff add_neg_le_neg_add_iff
+-/
 
+#print div_le_self_iff /-
 @[simp, to_additive]
 theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b := by simp [div_eq_mul_inv]
 #align div_le_self_iff div_le_self_iff
 #align sub_le_self_iff sub_le_self_iff
+-/
 
+#print le_div_self_iff /-
 @[simp, to_additive]
 theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by simp [div_eq_mul_inv]
 #align le_div_self_iff le_div_self_iff
 #align le_sub_self_iff le_sub_self_iff
+-/
 
 alias sub_le_self_iff ↔ _ sub_le_self
 #align sub_le_self sub_le_self
@@ -369,21 +451,27 @@ section TypeclassesLeftRightLt
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (swap (· * ·)) (· < ·)]
   {a b c d : α}
 
+#print inv_lt_inv_iff /-
 @[simp, to_additive]
 theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a := by
   rw [← mul_lt_mul_iff_left a, ← mul_lt_mul_iff_right b]; simp
 #align inv_lt_inv_iff inv_lt_inv_iff
 #align neg_lt_neg_iff neg_lt_neg_iff
+-/
 
+#print inv_lt' /-
 @[to_additive neg_lt]
 theorem inv_lt' : a⁻¹ < b ↔ b⁻¹ < a := by rw [← inv_lt_inv_iff, inv_inv]
 #align inv_lt' inv_lt'
 #align neg_lt neg_lt
+-/
 
+#print lt_inv' /-
 @[to_additive lt_neg]
 theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ := by rw [← inv_lt_inv_iff, inv_inv]
 #align lt_inv' lt_inv'
 #align lt_neg lt_neg
+-/
 
 alias lt_inv' ↔ lt_inv_of_lt_inv _
 #align lt_inv_of_lt_inv lt_inv_of_lt_inv
@@ -395,17 +483,21 @@ alias inv_lt' ↔ inv_lt_of_inv_lt' _
 
 attribute [to_additive neg_lt_of_neg_lt] inv_lt_of_inv_lt'
 
+#print mul_inv_lt_inv_mul_iff /-
 @[to_additive]
 theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
   rw [← mul_lt_mul_iff_left d, ← mul_lt_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
     inv_mul_cancel_right]
 #align mul_inv_lt_inv_mul_iff mul_inv_lt_inv_mul_iff
 #align add_neg_lt_neg_add_iff add_neg_lt_neg_add_iff
+-/
 
+#print div_lt_self_iff /-
 @[simp, to_additive]
 theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by simp [div_eq_mul_inv]
 #align div_lt_self_iff div_lt_self_iff
 #align sub_lt_self_iff sub_lt_self_iff
+-/
 
 alias sub_lt_self_iff ↔ _ sub_lt_self
 #align sub_lt_self sub_lt_self
@@ -420,20 +512,24 @@ section LeftLe
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)] {a : α}
 
+#print Left.inv_le_self /-
 @[to_additive]
 theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
   le_trans (Left.inv_le_one_iff.mpr h) h
 #align left.inv_le_self Left.inv_le_self
 #align left.neg_le_self Left.neg_le_self
+-/
 
 alias Left.neg_le_self ← neg_le_self
 #align neg_le_self neg_le_self
 
+#print Left.self_le_inv /-
 @[to_additive]
 theorem Left.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ :=
   le_trans h (Left.one_le_inv_iff.mpr h)
 #align left.self_le_inv Left.self_le_inv
 #align left.self_le_neg Left.self_le_neg
+-/
 
 end LeftLe
 
@@ -441,20 +537,24 @@ section LeftLt
 
 variable [CovariantClass α α (· * ·) (· < ·)] {a : α}
 
+#print Left.inv_lt_self /-
 @[to_additive]
 theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
   (Left.inv_lt_one_iff.mpr h).trans h
 #align left.inv_lt_self Left.inv_lt_self
 #align left.neg_lt_self Left.neg_lt_self
+-/
 
 alias Left.neg_lt_self ← neg_lt_self
 #align neg_lt_self neg_lt_self
 
+#print Left.self_lt_inv /-
 @[to_additive]
 theorem Left.self_lt_inv (h : a < 1) : a < a⁻¹ :=
   lt_trans h (Left.one_lt_inv_iff.mpr h)
 #align left.self_lt_inv Left.self_lt_inv
 #align left.self_lt_neg Left.self_lt_neg
+-/
 
 end LeftLt
 
@@ -462,17 +562,21 @@ section RightLe
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a : α}
 
+#print Right.inv_le_self /-
 @[to_additive]
 theorem Right.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
   le_trans (Right.inv_le_one_iff.mpr h) h
 #align right.inv_le_self Right.inv_le_self
 #align right.neg_le_self Right.neg_le_self
+-/
 
+#print Right.self_le_inv /-
 @[to_additive]
 theorem Right.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ :=
   le_trans h (Right.one_le_inv_iff.mpr h)
 #align right.self_le_inv Right.self_le_inv
 #align right.self_le_neg Right.self_le_neg
+-/
 
 end RightLe
 
@@ -480,17 +584,21 @@ section RightLt
 
 variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a : α}
 
+#print Right.inv_lt_self /-
 @[to_additive]
 theorem Right.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
   (Right.inv_lt_one_iff.mpr h).trans h
 #align right.inv_lt_self Right.inv_lt_self
 #align right.neg_lt_self Right.neg_lt_self
+-/
 
+#print Right.self_lt_inv /-
 @[to_additive]
 theorem Right.self_lt_inv (h : a < 1) : a < a⁻¹ :=
   lt_trans h (Right.one_lt_inv_iff.mpr h)
 #align right.self_lt_inv Right.self_lt_inv
 #align right.self_lt_neg Right.self_lt_neg
+-/
 
 end RightLt
 
@@ -506,22 +614,28 @@ section LE
 
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
+#print inv_mul_le_iff_le_mul' /-
 @[to_additive]
 theorem inv_mul_le_iff_le_mul' : c⁻¹ * a ≤ b ↔ a ≤ b * c := by rw [inv_mul_le_iff_le_mul, mul_comm]
 #align inv_mul_le_iff_le_mul' inv_mul_le_iff_le_mul'
 #align neg_add_le_iff_le_add' neg_add_le_iff_le_add'
+-/
 
+#print mul_inv_le_iff_le_mul' /-
 @[simp, to_additive]
 theorem mul_inv_le_iff_le_mul' : a * b⁻¹ ≤ c ↔ a ≤ b * c := by
   rw [← inv_mul_le_iff_le_mul, mul_comm]
 #align mul_inv_le_iff_le_mul' mul_inv_le_iff_le_mul'
 #align add_neg_le_iff_le_add' add_neg_le_iff_le_add'
+-/
 
+#print mul_inv_le_mul_inv_iff' /-
 @[to_additive add_neg_le_add_neg_iff]
 theorem mul_inv_le_mul_inv_iff' : a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b := by
   rw [mul_comm c, mul_inv_le_inv_mul_iff, mul_comm]
 #align mul_inv_le_mul_inv_iff' mul_inv_le_mul_inv_iff'
 #align add_neg_le_add_neg_iff add_neg_le_add_neg_iff
+-/
 
 end LE
 
@@ -529,22 +643,28 @@ section LT
 
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
+#print inv_mul_lt_iff_lt_mul' /-
 @[to_additive]
 theorem inv_mul_lt_iff_lt_mul' : c⁻¹ * a < b ↔ a < b * c := by rw [inv_mul_lt_iff_lt_mul, mul_comm]
 #align inv_mul_lt_iff_lt_mul' inv_mul_lt_iff_lt_mul'
 #align neg_add_lt_iff_lt_add' neg_add_lt_iff_lt_add'
+-/
 
+#print mul_inv_lt_iff_le_mul' /-
 @[simp, to_additive]
 theorem mul_inv_lt_iff_le_mul' : a * b⁻¹ < c ↔ a < b * c := by
   rw [← inv_mul_lt_iff_lt_mul, mul_comm]
 #align mul_inv_lt_iff_le_mul' mul_inv_lt_iff_le_mul'
 #align add_neg_lt_iff_le_add' add_neg_lt_iff_le_add'
+-/
 
+#print mul_inv_lt_mul_inv_iff' /-
 @[to_additive add_neg_lt_add_neg_iff]
 theorem mul_inv_lt_mul_inv_iff' : a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b := by
   rw [mul_comm c, mul_inv_lt_inv_mul_iff, mul_comm]
 #align mul_inv_lt_mul_inv_iff' mul_inv_lt_mul_inv_iff'
 #align add_neg_lt_add_neg_iff add_neg_lt_add_neg_iff
+-/
 
 end LT
 
@@ -670,54 +790,67 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
+#print div_le_div_iff_right /-
 @[simp, to_additive]
 theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b := by
   simpa only [div_eq_mul_inv] using mul_le_mul_iff_right _
 #align div_le_div_iff_right div_le_div_iff_right
 #align sub_le_sub_iff_right sub_le_sub_iff_right
+-/
 
+#print div_le_div_right' /-
 @[to_additive sub_le_sub_right]
 theorem div_le_div_right' (h : a ≤ b) (c : α) : a / c ≤ b / c :=
   (div_le_div_iff_right c).2 h
 #align div_le_div_right' div_le_div_right'
 #align sub_le_sub_right sub_le_sub_right
+-/
 
+#print one_le_div' /-
 @[simp, to_additive sub_nonneg]
 theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_le_div' one_le_div'
 #align sub_nonneg sub_nonneg
+-/
 
 alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
 #align le_of_sub_nonneg le_of_sub_nonneg
 #align sub_nonneg_of_le sub_nonneg_of_le
 
+#print div_le_one' /-
 @[simp, to_additive sub_nonpos]
 theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_one' div_le_one'
 #align sub_nonpos sub_nonpos
+-/
 
 alias sub_nonpos ↔ le_of_sub_nonpos sub_nonpos_of_le
 #align le_of_sub_nonpos le_of_sub_nonpos
 #align sub_nonpos_of_le sub_nonpos_of_le
 
+#print le_div_iff_mul_le /-
 @[to_additive]
 theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c := by
   rw [← mul_le_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
 #align le_div_iff_mul_le le_div_iff_mul_le
 #align le_sub_iff_add_le le_sub_iff_add_le
+-/
 
 alias le_sub_iff_add_le ↔ add_le_of_le_sub_right le_sub_right_of_add_le
 #align add_le_of_le_sub_right add_le_of_le_sub_right
 #align le_sub_right_of_add_le le_sub_right_of_add_le
 
+#print div_le_iff_le_mul /-
 @[to_additive]
 theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c := by
   rw [← mul_le_mul_iff_right c, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_iff_le_mul div_le_iff_le_mul
 #align sub_le_iff_le_add sub_le_iff_le_add
+-/
 
+#print AddGroup.toHasOrderedSub /-
 -- TODO: Should we get rid of `sub_le_iff_le_add` in favor of
 -- (a renamed version of) `tsub_le_iff_right`?
 -- see Note [lower instance priority]
@@ -725,6 +858,7 @@ instance (priority := 100) AddGroup.toHasOrderedSub {α : Type _} [AddGroup α]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] : OrderedSub α :=
   ⟨fun a b c => sub_le_iff_le_add⟩
 #align add_group.to_has_ordered_sub AddGroup.toHasOrderedSub
+-/
 
 end Right
 
@@ -734,18 +868,22 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
+#print div_le_div_iff_left /-
 @[simp, to_additive]
 theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_le_mul_iff_left a⁻¹, inv_mul_cancel_left,
     inv_mul_cancel_left, inv_le_inv_iff]
 #align div_le_div_iff_left div_le_div_iff_left
 #align sub_le_sub_iff_left sub_le_sub_iff_left
+-/
 
+#print div_le_div_left' /-
 @[to_additive sub_le_sub_left]
 theorem div_le_div_left' (h : a ≤ b) (c : α) : c / b ≤ c / a :=
   (div_le_div_iff_left c).2 h
 #align div_le_div_left' div_le_div_left'
 #align sub_le_sub_left sub_le_sub_left
+-/
 
 end Left
 
@@ -759,52 +897,66 @@ section LE
 
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
+#print div_le_div_iff' /-
 @[to_additive sub_le_sub_iff]
 theorem div_le_div_iff' : a / b ≤ c / d ↔ a * d ≤ c * b := by
   simpa only [div_eq_mul_inv] using mul_inv_le_mul_inv_iff'
 #align div_le_div_iff' div_le_div_iff'
 #align sub_le_sub_iff sub_le_sub_iff
+-/
 
+#print le_div_iff_mul_le' /-
 @[to_additive]
 theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c := by rw [le_div_iff_mul_le, mul_comm]
 #align le_div_iff_mul_le' le_div_iff_mul_le'
 #align le_sub_iff_add_le' le_sub_iff_add_le'
+-/
 
 alias le_sub_iff_add_le' ↔ add_le_of_le_sub_left le_sub_left_of_add_le
 #align add_le_of_le_sub_left add_le_of_le_sub_left
 #align le_sub_left_of_add_le le_sub_left_of_add_le
 
+#print div_le_iff_le_mul' /-
 @[to_additive]
 theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le_mul, mul_comm]
 #align div_le_iff_le_mul' div_le_iff_le_mul'
 #align sub_le_iff_le_add' sub_le_iff_le_add'
+-/
 
 alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
 #align le_add_of_sub_left_le le_add_of_sub_left_le
 #align sub_left_le_of_le_add sub_left_le_of_le_add
 
+#print inv_le_div_iff_le_mul /-
 @[simp, to_additive]
 theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b :=
   le_div_iff_mul_le.trans inv_mul_le_iff_le_mul'
 #align inv_le_div_iff_le_mul inv_le_div_iff_le_mul
 #align neg_le_sub_iff_le_add neg_le_sub_iff_le_add
+-/
 
+#print inv_le_div_iff_le_mul' /-
 @[to_additive]
 theorem inv_le_div_iff_le_mul' : a⁻¹ ≤ b / c ↔ c ≤ a * b := by rw [inv_le_div_iff_le_mul, mul_comm]
 #align inv_le_div_iff_le_mul' inv_le_div_iff_le_mul'
 #align neg_le_sub_iff_le_add' neg_le_sub_iff_le_add'
+-/
 
+#print div_le_comm /-
 @[to_additive]
 theorem div_le_comm : a / b ≤ c ↔ a / c ≤ b :=
   div_le_iff_le_mul'.trans div_le_iff_le_mul.symm
 #align div_le_comm div_le_comm
 #align sub_le_comm sub_le_comm
+-/
 
+#print le_div_comm /-
 @[to_additive]
 theorem le_div_comm : a ≤ b / c ↔ c ≤ b / a :=
   le_div_iff_mul_le'.trans le_div_iff_mul_le.symm
 #align le_div_comm le_div_comm
 #align le_sub_comm le_sub_comm
+-/
 
 end LE
 
@@ -812,6 +964,7 @@ section Preorder
 
 variable [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
+#print div_le_div'' /-
 @[to_additive sub_le_sub]
 theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c :=
   by
@@ -819,6 +972,7 @@ theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c :=
   exact mul_le_mul' hab hcd
 #align div_le_div'' div_le_div''
 #align sub_le_sub sub_le_sub
+-/
 
 end Preorder
 
@@ -834,33 +988,41 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c d : α}
 
+#print div_lt_div_iff_right /-
 @[simp, to_additive]
 theorem div_lt_div_iff_right (c : α) : a / c < b / c ↔ a < b := by
   simpa only [div_eq_mul_inv] using mul_lt_mul_iff_right _
 #align div_lt_div_iff_right div_lt_div_iff_right
 #align sub_lt_sub_iff_right sub_lt_sub_iff_right
+-/
 
+#print div_lt_div_right' /-
 @[to_additive sub_lt_sub_right]
 theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c :=
   (div_lt_div_iff_right c).2 h
 #align div_lt_div_right' div_lt_div_right'
 #align sub_lt_sub_right sub_lt_sub_right
+-/
 
+#print one_lt_div' /-
 @[simp, to_additive sub_pos]
 theorem one_lt_div' : 1 < a / b ↔ b < a := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_lt_div' one_lt_div'
 #align sub_pos sub_pos
+-/
 
 alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
 #align lt_of_sub_pos lt_of_sub_pos
 #align sub_pos_of_lt sub_pos_of_lt
 
+#print div_lt_one' /-
 @[simp, to_additive sub_neg]
 theorem div_lt_one' : a / b < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_one' div_lt_one'
 #align sub_neg sub_neg
+-/
 
 alias sub_neg ↔ lt_of_sub_neg sub_neg_of_lt
 #align lt_of_sub_neg lt_of_sub_neg
@@ -869,21 +1031,25 @@ alias sub_neg ↔ lt_of_sub_neg sub_neg_of_lt
 alias sub_neg ← sub_lt_zero
 #align sub_lt_zero sub_lt_zero
 
+#print lt_div_iff_mul_lt /-
 @[to_additive]
 theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c := by
   rw [← mul_lt_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
 #align lt_div_iff_mul_lt lt_div_iff_mul_lt
 #align lt_sub_iff_add_lt lt_sub_iff_add_lt
+-/
 
 alias lt_sub_iff_add_lt ↔ add_lt_of_lt_sub_right lt_sub_right_of_add_lt
 #align add_lt_of_lt_sub_right add_lt_of_lt_sub_right
 #align lt_sub_right_of_add_lt lt_sub_right_of_add_lt
 
+#print div_lt_iff_lt_mul /-
 @[to_additive]
 theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c := by
   rw [← mul_lt_mul_iff_right c, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_iff_lt_mul div_lt_iff_lt_mul
 #align sub_lt_iff_lt_add sub_lt_iff_lt_add
+-/
 
 alias sub_lt_iff_lt_add ↔ lt_add_of_sub_right_lt sub_right_lt_of_lt_add
 #align lt_add_of_sub_right_lt lt_add_of_sub_right_lt
@@ -896,24 +1062,30 @@ section Left
 variable [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (swap (· * ·)) (· < ·)]
   {a b c : α}
 
+#print div_lt_div_iff_left /-
 @[simp, to_additive]
 theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_lt_mul_iff_left a⁻¹, inv_mul_cancel_left,
     inv_mul_cancel_left, inv_lt_inv_iff]
 #align div_lt_div_iff_left div_lt_div_iff_left
 #align sub_lt_sub_iff_left sub_lt_sub_iff_left
+-/
 
+#print inv_lt_div_iff_lt_mul /-
 @[simp, to_additive]
 theorem inv_lt_div_iff_lt_mul : a⁻¹ < b / c ↔ c < a * b := by
   rw [div_eq_mul_inv, lt_mul_inv_iff_mul_lt, inv_mul_lt_iff_lt_mul]
 #align inv_lt_div_iff_lt_mul inv_lt_div_iff_lt_mul
 #align neg_lt_sub_iff_lt_add neg_lt_sub_iff_lt_add
+-/
 
+#print div_lt_div_left' /-
 @[to_additive sub_lt_sub_left]
 theorem div_lt_div_left' (h : a < b) (c : α) : c / b < c / a :=
   (div_lt_div_iff_left c).2 h
 #align div_lt_div_left' div_lt_div_left'
 #align sub_lt_sub_left sub_lt_sub_left
+-/
 
 end Left
 
@@ -927,47 +1099,59 @@ section LT
 
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
+#print div_lt_div_iff' /-
 @[to_additive sub_lt_sub_iff]
 theorem div_lt_div_iff' : a / b < c / d ↔ a * d < c * b := by
   simpa only [div_eq_mul_inv] using mul_inv_lt_mul_inv_iff'
 #align div_lt_div_iff' div_lt_div_iff'
 #align sub_lt_sub_iff sub_lt_sub_iff
+-/
 
+#print lt_div_iff_mul_lt' /-
 @[to_additive]
 theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c := by rw [lt_div_iff_mul_lt, mul_comm]
 #align lt_div_iff_mul_lt' lt_div_iff_mul_lt'
 #align lt_sub_iff_add_lt' lt_sub_iff_add_lt'
+-/
 
 alias lt_sub_iff_add_lt' ↔ add_lt_of_lt_sub_left lt_sub_left_of_add_lt
 #align add_lt_of_lt_sub_left add_lt_of_lt_sub_left
 #align lt_sub_left_of_add_lt lt_sub_left_of_add_lt
 
+#print div_lt_iff_lt_mul' /-
 @[to_additive]
 theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c := by rw [div_lt_iff_lt_mul, mul_comm]
 #align div_lt_iff_lt_mul' div_lt_iff_lt_mul'
 #align sub_lt_iff_lt_add' sub_lt_iff_lt_add'
+-/
 
 alias sub_lt_iff_lt_add' ↔ lt_add_of_sub_left_lt sub_left_lt_of_lt_add
 #align lt_add_of_sub_left_lt lt_add_of_sub_left_lt
 #align sub_left_lt_of_lt_add sub_left_lt_of_lt_add
 
+#print inv_lt_div_iff_lt_mul' /-
 @[to_additive]
 theorem inv_lt_div_iff_lt_mul' : b⁻¹ < a / c ↔ c < a * b :=
   lt_div_iff_mul_lt.trans inv_mul_lt_iff_lt_mul'
 #align inv_lt_div_iff_lt_mul' inv_lt_div_iff_lt_mul'
 #align neg_lt_sub_iff_lt_add' neg_lt_sub_iff_lt_add'
+-/
 
+#print div_lt_comm /-
 @[to_additive]
 theorem div_lt_comm : a / b < c ↔ a / c < b :=
   div_lt_iff_lt_mul'.trans div_lt_iff_lt_mul.symm
 #align div_lt_comm div_lt_comm
 #align sub_lt_comm sub_lt_comm
+-/
 
+#print lt_div_comm /-
 @[to_additive]
 theorem lt_div_comm : a < b / c ↔ c < b / a :=
   lt_div_iff_mul_lt'.trans lt_div_iff_mul_lt.symm
 #align lt_div_comm lt_div_comm
 #align lt_sub_comm lt_sub_comm
+-/
 
 end LT
 
@@ -975,6 +1159,7 @@ section Preorder
 
 variable [Preorder α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
+#print div_lt_div'' /-
 @[to_additive sub_lt_sub]
 theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c :=
   by
@@ -982,6 +1167,7 @@ theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c :=
   exact mul_lt_mul_of_lt_of_lt hab hcd
 #align div_lt_div'' div_lt_div''
 #align sub_lt_sub sub_lt_sub
+-/
 
 end Preorder
 
@@ -991,11 +1177,13 @@ section LinearOrder
 
 variable [Group α] [LinearOrder α]
 
+#print cmp_div_one' /-
 @[simp, to_additive cmp_sub_zero]
 theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
     cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel']
 #align cmp_div_one' cmp_div_one'
 #align cmp_sub_zero cmp_sub_zero
+-/
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
@@ -1003,18 +1191,23 @@ section VariableNames
 
 variable {a b c : α}
 
+#print le_of_forall_one_lt_lt_mul /-
 @[to_additive]
 theorem le_of_forall_one_lt_lt_mul (h : ∀ ε : α, 1 < ε → a < b * ε) : a ≤ b :=
   le_of_not_lt fun h₁ => lt_irrefl a (by simpa using h _ (lt_inv_mul_iff_lt.mpr h₁))
 #align le_of_forall_one_lt_lt_mul le_of_forall_one_lt_lt_mul
 #align le_of_forall_pos_lt_add le_of_forall_pos_lt_add
+-/
 
+#print le_iff_forall_one_lt_lt_mul /-
 @[to_additive]
 theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε :=
   ⟨fun h ε => lt_mul_of_le_of_one_lt h, le_of_forall_one_lt_lt_mul⟩
 #align le_iff_forall_one_lt_lt_mul le_iff_forall_one_lt_lt_mul
 #align le_iff_forall_pos_lt_add le_iff_forall_pos_lt_add
+-/
 
+#print div_le_inv_mul_iff /-
 /-  I (DT) introduced this lemma to prove (the additive version `sub_le_sub_flip` of)
 `div_le_div_flip` below.  Now I wonder what is the point of either of these lemmas... -/
 @[to_additive]
@@ -1026,7 +1219,9 @@ theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
       mul_le_mul' h h⟩
 #align div_le_inv_mul_iff div_le_inv_mul_iff
 #align sub_le_neg_add_iff sub_le_neg_add_iff
+-/
 
+#print div_le_div_flip /-
 --  What is the point of this lemma?  See comment about `div_le_inv_mul_iff` above.
 @[simp, to_additive]
 theorem div_le_div_flip {α : Type _} [CommGroup α] [LinearOrder α]
@@ -1036,6 +1231,7 @@ theorem div_le_div_flip {α : Type _} [CommGroup α] [LinearOrder α]
   exact div_le_inv_mul_iff
 #align div_le_div_flip div_le_div_flip
 #align sub_le_sub_flip sub_le_sub_flip
+-/
 
 end VariableNames
 
@@ -1080,12 +1276,15 @@ section LinearOrderedCommGroup
 
 variable [LinearOrderedCommGroup α] {a b c : α}
 
+#print LinearOrderedCommGroup.mul_lt_mul_left' /-
 @[to_additive LinearOrderedAddCommGroup.add_lt_add_left]
 theorem LinearOrderedCommGroup.mul_lt_mul_left' (a b : α) (h : a < b) (c : α) : c * a < c * b :=
   mul_lt_mul_left' h c
 #align linear_ordered_comm_group.mul_lt_mul_left' LinearOrderedCommGroup.mul_lt_mul_left'
 #align linear_ordered_add_comm_group.add_lt_add_left LinearOrderedAddCommGroup.add_lt_add_left
+-/
 
+#print eq_one_of_inv_eq' /-
 @[to_additive eq_zero_of_neg_eq]
 theorem eq_one_of_inv_eq' (h : a⁻¹ = a) : a = 1 :=
   match lt_trichotomy a 1 with
@@ -1098,7 +1297,9 @@ theorem eq_one_of_inv_eq' (h : a⁻¹ = a) : a = 1 :=
     absurd h₁ this.asymm
 #align eq_one_of_inv_eq' eq_one_of_inv_eq'
 #align eq_zero_of_neg_eq eq_zero_of_neg_eq
+-/
 
+#print exists_one_lt' /-
 @[to_additive exists_zero_lt]
 theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a :=
   by
@@ -1108,6 +1309,7 @@ theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a :=
   · exact ⟨y, h⟩
 #align exists_one_lt' exists_one_lt'
 #align exists_zero_lt exists_zero_lt
+-/
 
 #print LinearOrderedCommGroup.to_noMaxOrder /-
 -- see Note [lower instance priority]
@@ -1227,37 +1429,47 @@ section NormNumLemmas
 expected signatures.  -/
 variable [OrderedCommGroup α] {a b : α}
 
+#print inv_le_inv' /-
 @[to_additive neg_le_neg]
 theorem inv_le_inv' : a ≤ b → b⁻¹ ≤ a⁻¹ :=
   inv_le_inv_iff.mpr
 #align inv_le_inv' inv_le_inv'
 #align neg_le_neg neg_le_neg
+-/
 
+#print inv_lt_inv' /-
 @[to_additive neg_lt_neg]
 theorem inv_lt_inv' : a < b → b⁻¹ < a⁻¹ :=
   inv_lt_inv_iff.mpr
 #align inv_lt_inv' inv_lt_inv'
 #align neg_lt_neg neg_lt_neg
+-/
 
+#print inv_lt_one_of_one_lt /-
 --  The additive version is also a `linarith` lemma.
 @[to_additive]
 theorem inv_lt_one_of_one_lt : 1 < a → a⁻¹ < 1 :=
   inv_lt_one_iff_one_lt.mpr
 #align inv_lt_one_of_one_lt inv_lt_one_of_one_lt
 #align neg_neg_of_pos neg_neg_of_pos
+-/
 
+#print inv_le_one_of_one_le /-
 --  The additive version is also a `linarith` lemma.
 @[to_additive]
 theorem inv_le_one_of_one_le : 1 ≤ a → a⁻¹ ≤ 1 :=
   inv_le_one'.mpr
 #align inv_le_one_of_one_le inv_le_one_of_one_le
 #align neg_nonpos_of_nonneg neg_nonpos_of_nonneg
+-/
 
+#print one_le_inv_of_le_one /-
 @[to_additive neg_nonneg_of_nonpos]
 theorem one_le_inv_of_le_one : a ≤ 1 → 1 ≤ a⁻¹ :=
   one_le_inv'.mpr
 #align one_le_inv_of_le_one one_le_inv_of_le_one
 #align neg_nonneg_of_nonpos neg_nonneg_of_nonpos
+-/
 
 end NormNumLemmas
 
@@ -1266,29 +1478,37 @@ section
 variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)]
   [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [Preorder β] {f : β → α} {s : Set β}
 
+#print Monotone.inv /-
 @[to_additive]
 theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y hxy =>
   inv_le_inv_iff.2 (hf hxy)
 #align monotone.inv Monotone.inv
 #align monotone.neg Monotone.neg
+-/
 
+#print Antitone.inv /-
 @[to_additive]
 theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y hxy =>
   inv_le_inv_iff.2 (hf hxy)
 #align antitone.inv Antitone.inv
 #align antitone.neg Antitone.neg
+-/
 
+#print MonotoneOn.inv /-
 @[to_additive]
 theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_le_inv_iff.2 (hf hx hy hxy)
 #align monotone_on.inv MonotoneOn.inv
 #align monotone_on.neg MonotoneOn.neg
+-/
 
+#print AntitoneOn.inv /-
 @[to_additive]
 theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_le_inv_iff.2 (hf hx hy hxy)
 #align antitone_on.inv AntitoneOn.inv
 #align antitone_on.neg AntitoneOn.neg
+-/
 
 end
 
@@ -1297,29 +1517,37 @@ section
 variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· < ·)]
   [CovariantClass α α (swap (· * ·)) (· < ·)] [Preorder β] {f : β → α} {s : Set β}
 
+#print StrictMono.inv /-
 @[to_additive]
 theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := fun x y hxy =>
   inv_lt_inv_iff.2 (hf hxy)
 #align strict_mono.inv StrictMono.inv
 #align strict_mono.neg StrictMono.neg
+-/
 
+#print StrictAnti.inv /-
 @[to_additive]
 theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := fun x y hxy =>
   inv_lt_inv_iff.2 (hf hxy)
 #align strict_anti.inv StrictAnti.inv
 #align strict_anti.neg StrictAnti.neg
+-/
 
+#print StrictMonoOn.inv /-
 @[to_additive]
 theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_lt_inv_iff.2 (hf hx hy hxy)
 #align strict_mono_on.inv StrictMonoOn.inv
 #align strict_mono_on.neg StrictMonoOn.neg
+-/
 
+#print StrictAntiOn.inv /-
 @[to_additive]
 theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_lt_inv_iff.2 (hf hx hy hxy)
 #align strict_anti_on.inv StrictAntiOn.inv
 #align strict_anti_on.neg StrictAntiOn.neg
+-/
 
 end

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -1060,7 +1060,7 @@ class LinearOrderedAddCommGroup (α : Type u) extends OrderedAddCommGroup α, Li
   Instances should include number systems with an infinite element adjoined.` -/
 @[protect_proj]
 class LinearOrderedAddCommGroupWithTop (α : Type _) extends LinearOrderedAddCommMonoidWithTop α,
-  SubNegMonoid α, Nontrivial α where
+    SubNegMonoid α, Nontrivial α where
   neg_top : -(⊤ : α) = ⊤
   add_neg_cancel : ∀ a : α, a ≠ ⊤ → a + -a = 0
 #align linear_ordered_add_comm_group_with_top LinearOrderedAddCommGroupWithTop
@@ -1214,7 +1214,7 @@ def mkOfPositiveCone {α : Type _} [AddCommGroup α] (C : TotalPositiveCone α)
   {
     OrderedAddCommGroup.mkOfPositiveCone
       C.toPositiveCone with
-    le_total := fun a b => by convert C.nonneg_total (b - a); change C.nonneg _ = _; congr ; simp
+    le_total := fun a b => by convert C.nonneg_total (b - a); change C.nonneg _ = _; congr; simp
     decidableLe := fun a b => C.nonnegDecidable _ }
 #align linear_ordered_add_comm_group.mk_of_positive_cone LinearOrderedAddCommGroup.mkOfPositiveCone
 -/

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -1109,6 +1109,7 @@ theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a :=
 #align exists_one_lt' exists_one_lt'
 #align exists_zero_lt exists_zero_lt
 
+#print LinearOrderedCommGroup.to_noMaxOrder /-
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LinearOrderedCommGroup.to_noMaxOrder [Nontrivial α] : NoMaxOrder α :=
@@ -1117,7 +1118,9 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMaxOrder [Nontrivial α]
     exact fun a => ⟨a * y, lt_mul_of_one_lt_right' a hy⟩⟩
 #align linear_ordered_comm_group.to_no_max_order LinearOrderedCommGroup.to_noMaxOrder
 #align linear_ordered_add_comm_group.to_no_max_order LinearOrderedAddCommGroup.to_noMaxOrder
+-/
 
+#print LinearOrderedCommGroup.to_noMinOrder /-
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LinearOrderedCommGroup.to_noMinOrder [Nontrivial α] : NoMinOrder α :=
@@ -1126,6 +1129,7 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMinOrder [Nontrivial α]
     exact fun a => ⟨a / y, (div_lt_self_iff a).mpr hy⟩⟩
 #align linear_ordered_comm_group.to_no_min_order LinearOrderedCommGroup.to_noMinOrder
 #align linear_ordered_add_comm_group.to_no_min_order LinearOrderedAddCommGroup.to_noMinOrder
+-/
 
 #print LinearOrderedCommGroup.toLinearOrderedCancelCommMonoid /-
 -- See note [lower instance priority]

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -54,12 +54,6 @@ class OrderedCommGroup (α : Type u) extends CommGroup α, PartialOrder α where
 
 attribute [to_additive] OrderedCommGroup
 
-/- warning: ordered_comm_group.to_covariant_class_left_le -> OrderedCommGroup.to_covariantClass_left_le is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.96 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.98 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.96 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.98) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.111 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.113 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.111 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.113)
-Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_covariant_class_left_le OrderedCommGroup.to_covariantClass_left_leₓ'. -/
 @[to_additive]
 instance OrderedCommGroup.to_covariantClass_left_le (α : Type u) [OrderedCommGroup α] :
     CovariantClass α α (· * ·) (· ≤ ·)
@@ -80,12 +74,6 @@ instance (priority := 100) OrderedCommGroup.toOrderedCancelCommMonoid [OrderedCo
 example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (· + ·)) (· < ·) :=
   AddRightCancelSemigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
 
-/- warning: ordered_comm_group.to_contravariant_class_left_le -> OrderedCommGroup.to_contravariantClass_left_le is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.244 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.246 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.244 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.246) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.259 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.261 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.259 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.261)
-Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_leₓ'. -/
 -- Backporting note: this instance is not used,
 -- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
@@ -96,12 +84,6 @@ theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCom
 #align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
 #align ordered_add_comm_group.to_contravariant_class_left_le OrderedAddCommGroup.to_contravariantClass_left_le
 
-/- warning: ordered_comm_group.to_contravariant_class_right_le -> OrderedCommGroup.to_contravariantClass_right_le is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.315 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.317 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.315 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.317)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.330 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.332 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.330 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.332)
-Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_leₓ'. -/
 -- Backporting note: this instance is not used,
 -- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
@@ -120,95 +102,47 @@ section TypeclassesLeftLe
 
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
-/- warning: left.inv_le_one_iff -> Left.inv_le_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.446 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.448 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.446 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.448) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.461 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.463 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.461 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.463)] {a : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align left.inv_le_one_iff Left.inv_le_one_iffₓ'. -/
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.neg_nonpos_iff "Uses `left` co(ntra)variant."]
 theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by rw [← mul_le_mul_iff_left a]; simp
 #align left.inv_le_one_iff Left.inv_le_one_iff
 #align left.neg_nonpos_iff Left.neg_nonpos_iff
 
-/- warning: left.one_le_inv_iff -> Left.one_le_inv_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.547 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.549 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.547 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.549) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.562 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.564 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.562 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.564)] {a : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align left.one_le_inv_iff Left.one_le_inv_iffₓ'. -/
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.nonneg_neg_iff "Uses `left` co(ntra)variant."]
 theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by rw [← mul_le_mul_iff_left a]; simp
 #align left.one_le_inv_iff Left.one_le_inv_iff
 #align left.nonneg_neg_iff Left.nonneg_neg_iff
 
-/- warning: le_inv_mul_iff_mul_le -> le_inv_mul_iff_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) c)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align le_inv_mul_iff_mul_le le_inv_mul_iff_mul_leₓ'. -/
 @[simp, to_additive]
 theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c := by rw [← mul_le_mul_iff_left a]; simp
 #align le_inv_mul_iff_mul_le le_inv_mul_iff_mul_le
 #align le_neg_add_iff_add_le le_neg_add_iff_add_le
 
-/- warning: inv_mul_le_iff_le_mul -> inv_mul_le_iff_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.746 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.748 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.746 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.748) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.761 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.763 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.761 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.763)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-Case conversion may be inaccurate. Consider using '#align inv_mul_le_iff_le_mul inv_mul_le_iff_le_mulₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_le_iff_le_mul : b⁻¹ * a ≤ c ↔ a ≤ b * c := by
   rw [← mul_le_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_le_iff_le_mul inv_mul_le_iff_le_mul
 #align neg_add_le_iff_le_add neg_add_le_iff_le_add
 
-/- warning: inv_le_iff_one_le_mul' -> inv_le_iff_one_le_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.843 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.845 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.843 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.845) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.858 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.860 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.858 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.860)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b))
-Case conversion may be inaccurate. Consider using '#align inv_le_iff_one_le_mul' inv_le_iff_one_le_mul'ₓ'. -/
 @[to_additive neg_le_iff_add_nonneg']
 theorem inv_le_iff_one_le_mul' : a⁻¹ ≤ b ↔ 1 ≤ a * b :=
   (mul_le_mul_iff_left a).symm.trans <| by rw [mul_inv_self]
 #align inv_le_iff_one_le_mul' inv_le_iff_one_le_mul'
 #align neg_le_iff_add_nonneg' neg_le_iff_add_nonneg'
 
-/- warning: le_inv_iff_mul_le_one_left -> le_inv_iff_mul_le_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.943 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.945 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.943 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.945) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.958 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.960 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.958 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.960)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align le_inv_iff_mul_le_one_left le_inv_iff_mul_le_one_leftₓ'. -/
 @[to_additive]
 theorem le_inv_iff_mul_le_one_left : a ≤ b⁻¹ ↔ b * a ≤ 1 :=
   (mul_le_mul_iff_left b).symm.trans <| by rw [mul_inv_self]
 #align le_inv_iff_mul_le_one_left le_inv_iff_mul_le_one_left
 #align le_neg_iff_add_nonpos_left le_neg_iff_add_nonpos_left
 
-/- warning: le_inv_mul_iff_le -> le_inv_mul_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a)) (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1043 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1045 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1043 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1045) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1058 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1060 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1058 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1060)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a)) (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align le_inv_mul_iff_le le_inv_mul_iff_leₓ'. -/
 @[to_additive]
 theorem le_inv_mul_iff_le : 1 ≤ b⁻¹ * a ↔ b ≤ a := by
   rw [← mul_le_mul_iff_left b, mul_one, mul_inv_cancel_left]
 #align le_inv_mul_iff_le le_inv_mul_iff_le
 #align le_neg_add_iff_le le_neg_add_iff_le
 
-/- warning: inv_mul_le_one_iff -> inv_mul_le_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1139 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1141 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1139 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1141) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1154 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1156 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1154 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1156)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align inv_mul_le_one_iff inv_mul_le_one_iffₓ'. -/
 @[to_additive]
 theorem inv_mul_le_one_iff : a⁻¹ * b ≤ 1 ↔ b ≤ a :=
   trans inv_mul_le_iff_le_mul <| by rw [mul_one]
@@ -221,12 +155,6 @@ section TypeclassesLeftLt
 
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c : α}
 
-/- warning: left.one_lt_inv_iff -> Left.one_lt_inv_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align left.one_lt_inv_iff Left.one_lt_inv_iffₓ'. -/
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.neg_pos_iff "Uses `left` co(ntra)variant."]
 theorem Left.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
@@ -234,12 +162,6 @@ theorem Left.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
 #align left.one_lt_inv_iff Left.one_lt_inv_iff
 #align left.neg_pos_iff Left.neg_pos_iff
 
-/- warning: left.inv_lt_one_iff -> Left.inv_lt_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align left.inv_lt_one_iff Left.inv_lt_one_iffₓ'. -/
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.neg_neg_iff "Uses `left` co(ntra)variant."]
 theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
@@ -247,71 +169,35 @@ theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
 #align left.inv_lt_one_iff Left.inv_lt_one_iff
 #align left.neg_neg_iff Left.neg_neg_iff
 
-/- warning: lt_inv_mul_iff_mul_lt -> lt_inv_mul_iff_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) c)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align lt_inv_mul_iff_mul_lt lt_inv_mul_iff_mul_ltₓ'. -/
 @[simp, to_additive]
 theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c := by rw [← mul_lt_mul_iff_left a]; simp
 #align lt_inv_mul_iff_mul_lt lt_inv_mul_iff_mul_lt
 #align lt_neg_add_iff_add_lt lt_neg_add_iff_add_lt
 
-/- warning: inv_mul_lt_iff_lt_mul -> inv_mul_lt_iff_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-Case conversion may be inaccurate. Consider using '#align inv_mul_lt_iff_lt_mul inv_mul_lt_iff_lt_mulₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_lt_iff_lt_mul : b⁻¹ * a < c ↔ a < b * c := by
   rw [← mul_lt_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_lt_iff_lt_mul inv_mul_lt_iff_lt_mul
 #align neg_add_lt_iff_lt_add neg_add_lt_iff_lt_add
 
-/- warning: inv_lt_iff_one_lt_mul' -> inv_lt_iff_one_lt_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1678 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1680 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1678 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1680) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1693 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1695 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1693 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1695)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b))
-Case conversion may be inaccurate. Consider using '#align inv_lt_iff_one_lt_mul' inv_lt_iff_one_lt_mul'ₓ'. -/
 @[to_additive]
 theorem inv_lt_iff_one_lt_mul' : a⁻¹ < b ↔ 1 < a * b :=
   (mul_lt_mul_iff_left a).symm.trans <| by rw [mul_inv_self]
 #align inv_lt_iff_one_lt_mul' inv_lt_iff_one_lt_mul'
 #align neg_lt_iff_pos_add' neg_lt_iff_pos_add'
 
-/- warning: lt_inv_iff_mul_lt_one' -> lt_inv_iff_mul_lt_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1777 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1779 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1777 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1779) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1792 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1794 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1792 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1794)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align lt_inv_iff_mul_lt_one' lt_inv_iff_mul_lt_one'ₓ'. -/
 @[to_additive]
 theorem lt_inv_iff_mul_lt_one' : a < b⁻¹ ↔ b * a < 1 :=
   (mul_lt_mul_iff_left b).symm.trans <| by rw [mul_inv_self]
 #align lt_inv_iff_mul_lt_one' lt_inv_iff_mul_lt_one'
 #align lt_neg_iff_add_neg' lt_neg_iff_add_neg'
 
-/- warning: lt_inv_mul_iff_lt -> lt_inv_mul_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a)) (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1876 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1878 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1876 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1878) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1891 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1893 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1891 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1893)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a)) (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align lt_inv_mul_iff_lt lt_inv_mul_iff_ltₓ'. -/
 @[to_additive]
 theorem lt_inv_mul_iff_lt : 1 < b⁻¹ * a ↔ b < a := by
   rw [← mul_lt_mul_iff_left b, mul_one, mul_inv_cancel_left]
 #align lt_inv_mul_iff_lt lt_inv_mul_iff_lt
 #align lt_neg_add_iff_lt lt_neg_add_iff_lt
 
-/- warning: inv_mul_lt_one_iff -> inv_mul_lt_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1971 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1973 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1971 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1973) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1986 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1988 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1986 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1988)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align inv_mul_lt_one_iff inv_mul_lt_one_iffₓ'. -/
 @[to_additive]
 theorem inv_mul_lt_one_iff : a⁻¹ * b < 1 ↔ b < a :=
   trans inv_mul_lt_iff_lt_mul <| by rw [mul_one]
@@ -324,108 +210,54 @@ section TypeclassesRightLe
 
 variable [LE α] [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
-/- warning: right.inv_le_one_iff -> Right.inv_le_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2128 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2130 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2128 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2130)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2143 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2145 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2143 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2145)] {a : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align right.inv_le_one_iff Right.inv_le_one_iffₓ'. -/
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.neg_nonpos_iff "Uses `right` co(ntra)variant."]
 theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by rw [← mul_le_mul_iff_right a]; simp
 #align right.inv_le_one_iff Right.inv_le_one_iff
 #align right.neg_nonpos_iff Right.neg_nonpos_iff
 
-/- warning: right.one_le_inv_iff -> Right.one_le_inv_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2231 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2233 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2231 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2233)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2246 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2248 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2246 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2248)] {a : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align right.one_le_inv_iff Right.one_le_inv_iffₓ'. -/
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.nonneg_neg_iff "Uses `right` co(ntra)variant."]
 theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by rw [← mul_le_mul_iff_right a]; simp
 #align right.one_le_inv_iff Right.one_le_inv_iff
 #align right.nonneg_neg_iff Right.nonneg_neg_iff
 
-/- warning: inv_le_iff_one_le_mul -> inv_le_iff_one_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2331 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2333 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2331 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2333)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2346 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2348 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2346 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2348)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a))
-Case conversion may be inaccurate. Consider using '#align inv_le_iff_one_le_mul inv_le_iff_one_le_mulₓ'. -/
 @[to_additive neg_le_iff_add_nonneg]
 theorem inv_le_iff_one_le_mul : a⁻¹ ≤ b ↔ 1 ≤ b * a :=
   (mul_le_mul_iff_right a).symm.trans <| by rw [inv_mul_self]
 #align inv_le_iff_one_le_mul inv_le_iff_one_le_mul
 #align neg_le_iff_add_nonneg neg_le_iff_add_nonneg
 
-/- warning: le_inv_iff_mul_le_one_right -> le_inv_iff_mul_le_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2433 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2435 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2433 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2435)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2448 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2450 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2448 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2450)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align le_inv_iff_mul_le_one_right le_inv_iff_mul_le_one_rightₓ'. -/
 @[to_additive]
 theorem le_inv_iff_mul_le_one_right : a ≤ b⁻¹ ↔ a * b ≤ 1 :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align le_inv_iff_mul_le_one_right le_inv_iff_mul_le_one_right
 #align le_neg_iff_add_nonpos_right le_neg_iff_add_nonpos_right
 
-/- warning: mul_inv_le_iff_le_mul -> mul_inv_le_iff_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2535 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2537 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2535 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2537)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2550 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2552 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2550 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2552)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-Case conversion may be inaccurate. Consider using '#align mul_inv_le_iff_le_mul mul_inv_le_iff_le_mulₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_le_iff_le_mul : a * b⁻¹ ≤ c ↔ a ≤ c * b :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align mul_inv_le_iff_le_mul mul_inv_le_iff_le_mul
 #align add_neg_le_iff_le_add add_neg_le_iff_le_add
 
-/- warning: le_mul_inv_iff_mul_le -> le_mul_inv_iff_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2639 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2641 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2639 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2641)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2654 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2656 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2654 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2656)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b) a)
-Case conversion may be inaccurate. Consider using '#align le_mul_inv_iff_mul_le le_mul_inv_iff_mul_leₓ'. -/
 @[simp, to_additive]
 theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align le_mul_inv_iff_mul_le le_mul_inv_iff_mul_le
 #align le_add_neg_iff_add_le le_add_neg_iff_add_le
 
-/- warning: mul_inv_le_one_iff_le -> mul_inv_le_one_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LE.le.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2743 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2745 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2743 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2745)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2758 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2760 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2758 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2760)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align mul_inv_le_one_iff_le mul_inv_le_one_iff_leₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_le_one_iff_le : a * b⁻¹ ≤ 1 ↔ a ≤ b :=
   mul_inv_le_iff_le_mul.trans <| by rw [one_mul]
 #align mul_inv_le_one_iff_le mul_inv_le_one_iff_le
 #align add_neg_nonpos_iff_le add_neg_nonpos_iff_le
 
-/- warning: le_mul_inv_iff_le -> le_mul_inv_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))) (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2841 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2843 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2841 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2843)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2856 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2858 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2856 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2858)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))) (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align le_mul_inv_iff_le le_mul_inv_iff_leₓ'. -/
 @[to_additive]
 theorem le_mul_inv_iff_le : 1 ≤ a * b⁻¹ ↔ b ≤ a := by
   rw [← mul_le_mul_iff_right b, one_mul, inv_mul_cancel_right]
 #align le_mul_inv_iff_le le_mul_inv_iff_le
 #align le_add_neg_iff_le le_add_neg_iff_le
 
-/- warning: mul_inv_le_one_iff -> mul_inv_le_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2939 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2941 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2939 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2941)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2954 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2956 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2954 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.2956)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align mul_inv_le_one_iff mul_inv_le_one_iffₓ'. -/
 @[to_additive]
 theorem mul_inv_le_one_iff : b * a⁻¹ ≤ 1 ↔ b ≤ a :=
   trans mul_inv_le_iff_le_mul <| by rw [one_mul]
@@ -438,12 +270,6 @@ section TypeclassesRightLt
 
 variable [LT α] [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c : α}
 
-/- warning: right.inv_lt_one_iff -> Right.inv_lt_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3096 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3098 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3096 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3098)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3111 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3113 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3111 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3113)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align right.inv_lt_one_iff Right.inv_lt_one_iffₓ'. -/
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.neg_neg_iff "Uses `right` co(ntra)variant."]
 theorem Right.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
@@ -451,12 +277,6 @@ theorem Right.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
 #align right.inv_lt_one_iff Right.inv_lt_one_iff
 #align right.neg_neg_iff Right.neg_neg_iff
 
-/- warning: right.one_lt_inv_iff -> Right.one_lt_inv_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3196 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3198 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3196 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3198)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3211 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3213 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3211 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3213)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align right.one_lt_inv_iff Right.one_lt_inv_iffₓ'. -/
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.neg_pos_iff "Uses `right` co(ntra)variant."]
 theorem Right.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
@@ -464,84 +284,42 @@ theorem Right.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
 #align right.one_lt_inv_iff Right.one_lt_inv_iff
 #align right.neg_pos_iff Right.neg_pos_iff
 
-/- warning: inv_lt_iff_one_lt_mul -> inv_lt_iff_one_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3293 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3295 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3293 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3295)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3308 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3310 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3308 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3310)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b a))
-Case conversion may be inaccurate. Consider using '#align inv_lt_iff_one_lt_mul inv_lt_iff_one_lt_mulₓ'. -/
 @[to_additive]
 theorem inv_lt_iff_one_lt_mul : a⁻¹ < b ↔ 1 < b * a :=
   (mul_lt_mul_iff_right a).symm.trans <| by rw [inv_mul_self]
 #align inv_lt_iff_one_lt_mul inv_lt_iff_one_lt_mul
 #align neg_lt_iff_pos_add neg_lt_iff_pos_add
 
-/- warning: lt_inv_iff_mul_lt_one -> lt_inv_iff_mul_lt_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3395 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3397 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3395 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3397)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3410 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3412 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3410 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3412)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align lt_inv_iff_mul_lt_one lt_inv_iff_mul_lt_oneₓ'. -/
 @[to_additive]
 theorem lt_inv_iff_mul_lt_one : a < b⁻¹ ↔ a * b < 1 :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align lt_inv_iff_mul_lt_one lt_inv_iff_mul_lt_one
 #align lt_neg_iff_add_neg lt_neg_iff_add_neg
 
-/- warning: mul_inv_lt_iff_lt_mul -> mul_inv_lt_iff_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3497 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3499 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3497 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3499)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3512 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3514 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3512 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3514)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-Case conversion may be inaccurate. Consider using '#align mul_inv_lt_iff_lt_mul mul_inv_lt_iff_lt_mulₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_lt_iff_lt_mul : a * b⁻¹ < c ↔ a < c * b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right]
 #align mul_inv_lt_iff_lt_mul mul_inv_lt_iff_lt_mul
 #align add_neg_lt_iff_lt_add add_neg_lt_iff_lt_add
 
-/- warning: lt_mul_inv_iff_mul_lt -> lt_mul_inv_iff_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3596 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3598 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3596 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3598)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3611 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3613 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3611 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3613)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b) a)
-Case conversion may be inaccurate. Consider using '#align lt_mul_inv_iff_mul_lt lt_mul_inv_iff_mul_ltₓ'. -/
 @[simp, to_additive]
 theorem lt_mul_inv_iff_mul_lt : c < a * b⁻¹ ↔ c * b < a :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align lt_mul_inv_iff_mul_lt lt_mul_inv_iff_mul_lt
 #align lt_add_neg_iff_add_lt lt_add_neg_iff_add_lt
 
-/- warning: inv_mul_lt_one_iff_lt -> inv_mul_lt_one_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3700 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3702 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3700 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3702)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3715 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3717 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3715 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3717)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align inv_mul_lt_one_iff_lt inv_mul_lt_one_iff_ltₓ'. -/
 @[simp, to_additive]
 theorem inv_mul_lt_one_iff_lt : a * b⁻¹ < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right, one_mul]
 #align inv_mul_lt_one_iff_lt inv_mul_lt_one_iff_lt
 #align neg_add_neg_iff_lt neg_add_neg_iff_lt
 
-/- warning: lt_mul_inv_iff_lt -> lt_mul_inv_iff_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b))) (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3798 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3800 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3798 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3800)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3813 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3815 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3813 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3815)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b))) (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align lt_mul_inv_iff_lt lt_mul_inv_iff_ltₓ'. -/
 @[to_additive]
 theorem lt_mul_inv_iff_lt : 1 < a * b⁻¹ ↔ b < a := by
   rw [← mul_lt_mul_iff_right b, one_mul, inv_mul_cancel_right]
 #align lt_mul_inv_iff_lt lt_mul_inv_iff_lt
 #align lt_add_neg_iff_lt lt_add_neg_iff_lt
 
-/- warning: mul_inv_lt_one_iff -> mul_inv_lt_one_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3896 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3898 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3896 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3898)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3911 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3913 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3911 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.3913)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align mul_inv_lt_one_iff mul_inv_lt_one_iffₓ'. -/
 @[to_additive]
 theorem mul_inv_lt_one_iff : b * a⁻¹ < 1 ↔ b < a :=
   trans mul_inv_lt_iff_lt_mul <| by rw [one_mul]
@@ -555,33 +333,15 @@ section TypeclassesLeftRightLe
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] [CovariantClass α α (swap (· * ·)) (· ≤ ·)]
   {a b c d : α}
 
-/- warning: inv_le_inv_iff -> inv_le_inv_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4084 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4086 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4084 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4086) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4099 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4101 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4099 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4101)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4121 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4123 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4121 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4123)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4136 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4138 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4136 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4138)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align inv_le_inv_iff inv_le_inv_iffₓ'. -/
 @[simp, to_additive]
 theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
   rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]; simp
 #align inv_le_inv_iff inv_le_inv_iff
 #align neg_le_neg_iff neg_le_neg_iff
 
-/- warning: le_of_neg_le_neg -> le_of_neg_le_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) a) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) b)) -> (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4084 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4086 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4084 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4086) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4099 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4101 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4099 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4101)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4121 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4123 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4121 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4123)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4136 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4138 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4136 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4138)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) a) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) b)) -> (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align le_of_neg_le_neg le_of_neg_le_negₓ'. -/
 alias neg_le_neg_iff ↔ le_of_neg_le_neg _
 #align le_of_neg_le_neg le_of_neg_le_neg
 
-/- warning: mul_inv_le_inv_mul_iff -> mul_inv_le_inv_mul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α} {d : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) d) c)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) d a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4224 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4226 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4224 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4226) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4239 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4241 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4239 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4241)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4261 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4263 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4261 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4263)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4276 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4278 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4276 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4278)] {a : α} {b : α} {c : α} {d : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) d) c)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) d a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-Case conversion may be inaccurate. Consider using '#align mul_inv_le_inv_mul_iff mul_inv_le_inv_mul_iffₓ'. -/
 @[to_additive]
 theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b := by
   rw [← mul_le_mul_iff_left d, ← mul_le_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
@@ -589,34 +349,16 @@ theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b :
 #align mul_inv_le_inv_mul_iff mul_inv_le_inv_mul_iff
 #align add_neg_le_neg_add_iff add_neg_le_neg_add_iff
 
-/- warning: div_le_self_iff -> div_le_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] (a : α) {b : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) a) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4368 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4370 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4368 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4370) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4383 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4385 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4383 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4385)] (_inst_4 : α) {a : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) _inst_4 a) _inst_4) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align div_le_self_iff div_le_self_iffₓ'. -/
 @[simp, to_additive]
 theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b := by simp [div_eq_mul_inv]
 #align div_le_self_iff div_le_self_iff
 #align sub_le_self_iff sub_le_self_iff
 
-/- warning: le_div_self_iff -> le_div_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] (a : α) {b : α}, Iff (LE.le.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b)) (LE.le.{u1} α _inst_2 b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4474 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4476 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4474 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4476) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4489 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4491 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4489 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4491)] (_inst_4 : α) {a : α}, Iff (LE.le.{u1} α _inst_2 _inst_4 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) _inst_4 a)) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align le_div_self_iff le_div_self_iffₓ'. -/
 @[simp, to_additive]
 theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by simp [div_eq_mul_inv]
 #align le_div_self_iff le_div_self_iff
 #align le_sub_self_iff le_sub_self_iff
 
-/- warning: sub_le_self -> sub_le_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] (a : α) {b : α}, (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) b) -> (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4368 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4370 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4368 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4370) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4383 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4385 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4383 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4385)] (_inst_4 : α) {a : α}, (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) a) -> (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) _inst_4 a) _inst_4)
-Case conversion may be inaccurate. Consider using '#align sub_le_self sub_le_selfₓ'. -/
 alias sub_le_self_iff ↔ _ sub_le_self
 #align sub_le_self sub_le_self
 
@@ -627,68 +369,32 @@ section TypeclassesLeftRightLt
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (swap (· * ·)) (· < ·)]
   {a b c d : α}
 
-/- warning: inv_lt_inv_iff -> inv_lt_inv_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4674 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4676 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4674 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4676) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4689 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4691 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4689 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4691)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4711 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4713 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4711 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4713)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4726 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4728 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4726 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4728)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align inv_lt_inv_iff inv_lt_inv_iffₓ'. -/
 @[simp, to_additive]
 theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a := by
   rw [← mul_lt_mul_iff_left a, ← mul_lt_mul_iff_right b]; simp
 #align inv_lt_inv_iff inv_lt_inv_iff
 #align neg_lt_neg_iff neg_lt_neg_iff
 
-/- warning: inv_lt' -> inv_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4812 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4814 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4812 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4814) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4827 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4829 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4827 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4829)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4849 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4851 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4849 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4851)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4864 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4866 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4864 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4866)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a)
-Case conversion may be inaccurate. Consider using '#align inv_lt' inv_lt'ₓ'. -/
 @[to_additive neg_lt]
 theorem inv_lt' : a⁻¹ < b ↔ b⁻¹ < a := by rw [← inv_lt_inv_iff, inv_inv]
 #align inv_lt' inv_lt'
 #align neg_lt neg_lt
 
-/- warning: lt_inv' -> lt_inv' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (LT.lt.{u1} α _inst_2 b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4943 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4945 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4943 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4945) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4958 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4960 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4958 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4960)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4980 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4982 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4980 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4982)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4995 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4997 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4995 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4997)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LT.lt.{u1} α _inst_2 b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align lt_inv' lt_inv'ₓ'. -/
 @[to_additive lt_neg]
 theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ := by rw [← inv_lt_inv_iff, inv_inv]
 #align lt_inv' lt_inv'
 #align lt_neg lt_neg
 
-/- warning: lt_inv_of_lt_inv -> lt_inv_of_lt_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) -> (LT.lt.{u1} α _inst_2 b (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4943 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4945 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4943 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4945) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4958 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4960 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4958 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4960)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4980 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4982 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4980 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4982)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4995 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4997 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4995 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4997)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) -> (LT.lt.{u1} α _inst_2 b (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align lt_inv_of_lt_inv lt_inv_of_lt_invₓ'. -/
 alias lt_inv' ↔ lt_inv_of_lt_inv _
 #align lt_inv_of_lt_inv lt_inv_of_lt_inv
 
 attribute [to_additive] lt_inv_of_lt_inv
 
-/- warning: inv_lt_of_inv_lt' -> inv_lt_of_inv_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b) -> (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4812 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4814 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4812 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4814) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4827 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4829 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4827 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4829)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4849 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4851 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4849 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4851)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4864 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4866 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4864 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4866)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b) -> (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a)
-Case conversion may be inaccurate. Consider using '#align inv_lt_of_inv_lt' inv_lt_of_inv_lt'ₓ'. -/
 alias inv_lt' ↔ inv_lt_of_inv_lt' _
 #align inv_lt_of_inv_lt' inv_lt_of_inv_lt'
 
 attribute [to_additive neg_lt_of_neg_lt] inv_lt_of_inv_lt'
 
-/- warning: mul_inv_lt_inv_mul_iff -> mul_inv_lt_inv_mul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α} {d : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) d) c)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) d a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5082 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5084 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5082 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5084) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5097 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5099 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5097 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5099)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5119 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5121 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5119 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5121)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5134 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5136 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5134 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5136)] {a : α} {b : α} {c : α} {d : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) d) c)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) d a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) c b))
-Case conversion may be inaccurate. Consider using '#align mul_inv_lt_inv_mul_iff mul_inv_lt_inv_mul_iffₓ'. -/
 @[to_additive]
 theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
   rw [← mul_lt_mul_iff_left d, ← mul_lt_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
@@ -696,23 +402,11 @@ theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
 #align mul_inv_lt_inv_mul_iff mul_inv_lt_inv_mul_iff
 #align add_neg_lt_neg_add_iff add_neg_lt_neg_add_iff
 
-/- warning: div_lt_self_iff -> div_lt_self_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] (a : α) {b : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) a) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5226 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5228 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5226 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5228) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5241 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5243 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5241 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5243)] (_inst_4 : α) {a : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) _inst_4 a) _inst_4) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align div_lt_self_iff div_lt_self_iffₓ'. -/
 @[simp, to_additive]
 theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by simp [div_eq_mul_inv]
 #align div_lt_self_iff div_lt_self_iff
 #align sub_lt_self_iff sub_lt_self_iff
 
-/- warning: sub_lt_self -> sub_lt_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] (a : α) {b : α}, (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) b) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5226 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5228 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5226 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5228) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5241 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5243 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5241 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5243)] (_inst_4 : α) {a : α}, (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) a) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) _inst_4 a) _inst_4)
-Case conversion may be inaccurate. Consider using '#align sub_lt_self sub_lt_selfₓ'. -/
 alias sub_lt_self_iff ↔ _ sub_lt_self
 #align sub_lt_self sub_lt_self
 
@@ -726,33 +420,15 @@ section LeftLe
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)] {a : α}
 
-/- warning: left.inv_le_self -> Left.inv_le_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
-Case conversion may be inaccurate. Consider using '#align left.inv_le_self Left.inv_le_selfₓ'. -/
 @[to_additive]
 theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
   le_trans (Left.inv_le_one_iff.mpr h) h
 #align left.inv_le_self Left.inv_le_self
 #align left.neg_le_self Left.neg_le_self
 
-/- warning: neg_le_self -> neg_le_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) a) a)
-Case conversion may be inaccurate. Consider using '#align neg_le_self neg_le_selfₓ'. -/
 alias Left.neg_le_self ← neg_le_self
 #align neg_le_self neg_le_self
 
-/- warning: left.self_le_inv -> Left.self_le_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5463 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5465 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5463 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5465) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5478 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5480 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5478 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5480)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align left.self_le_inv Left.self_le_invₓ'. -/
 @[to_additive]
 theorem Left.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ :=
   le_trans h (Left.one_le_inv_iff.mpr h)
@@ -765,33 +441,15 @@ section LeftLt
 
 variable [CovariantClass α α (· * ·) (· < ·)] {a : α}
 
-/- warning: left.inv_lt_self -> Left.inv_lt_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
-Case conversion may be inaccurate. Consider using '#align left.inv_lt_self Left.inv_lt_selfₓ'. -/
 @[to_additive]
 theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
   (Left.inv_lt_one_iff.mpr h).trans h
 #align left.inv_lt_self Left.inv_lt_self
 #align left.neg_lt_self Left.neg_lt_self
 
-/- warning: neg_lt_self -> neg_lt_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) a) a)
-Case conversion may be inaccurate. Consider using '#align neg_lt_self neg_lt_selfₓ'. -/
 alias Left.neg_lt_self ← neg_lt_self
 #align neg_lt_self neg_lt_self
 
-/- warning: left.self_lt_inv -> Left.self_lt_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5646 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5648 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5646 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5648) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5661 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5663 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5661 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5663)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align left.self_lt_inv Left.self_lt_invₓ'. -/
 @[to_additive]
 theorem Left.self_lt_inv (h : a < 1) : a < a⁻¹ :=
   lt_trans h (Left.one_lt_inv_iff.mpr h)
@@ -804,24 +462,12 @@ section RightLe
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a : α}
 
-/- warning: right.inv_le_self -> Right.inv_le_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5766 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5768 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5766 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5768)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5781 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5783 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5781 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5783)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
-Case conversion may be inaccurate. Consider using '#align right.inv_le_self Right.inv_le_selfₓ'. -/
 @[to_additive]
 theorem Right.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
   le_trans (Right.inv_le_one_iff.mpr h) h
 #align right.inv_le_self Right.inv_le_self
 #align right.neg_le_self Right.neg_le_self
 
-/- warning: right.self_le_inv -> Right.self_le_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5836 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5838 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5836 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5838)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5851 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5853 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5851 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5853)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align right.self_le_inv Right.self_le_invₓ'. -/
 @[to_additive]
 theorem Right.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ :=
   le_trans h (Right.one_le_inv_iff.mpr h)
@@ -834,24 +480,12 @@ section RightLt
 
 variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a : α}
 
-/- warning: right.inv_lt_self -> Right.inv_lt_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5956 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5958 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5956 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5958)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5971 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5973 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5971 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5973)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
-Case conversion may be inaccurate. Consider using '#align right.inv_lt_self Right.inv_lt_selfₓ'. -/
 @[to_additive]
 theorem Right.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
   (Right.inv_lt_one_iff.mpr h).trans h
 #align right.inv_lt_self Right.inv_lt_self
 #align right.neg_lt_self Right.neg_lt_self
 
-/- warning: right.self_lt_inv -> Right.self_lt_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6026 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6028 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6026 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6028)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6041 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6043 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6041 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6043)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align right.self_lt_inv Right.self_lt_invₓ'. -/
 @[to_additive]
 theorem Right.self_lt_inv (h : a < 1) : a < a⁻¹ :=
   lt_trans h (Right.one_lt_inv_iff.mpr h)
@@ -872,35 +506,17 @@ section LE
 
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
-/- warning: inv_mul_le_iff_le_mul' -> inv_mul_le_iff_le_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) c) a) b) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6153 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6155 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6153 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6155) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6168 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6170 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6168 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6170)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) c) a) b) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align inv_mul_le_iff_le_mul' inv_mul_le_iff_le_mul'ₓ'. -/
 @[to_additive]
 theorem inv_mul_le_iff_le_mul' : c⁻¹ * a ≤ b ↔ a ≤ b * c := by rw [inv_mul_le_iff_le_mul, mul_comm]
 #align inv_mul_le_iff_le_mul' inv_mul_le_iff_le_mul'
 #align neg_add_le_iff_le_add' neg_add_le_iff_le_add'
 
-/- warning: mul_inv_le_iff_le_mul' -> mul_inv_le_iff_le_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) b)) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6249 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6251 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6249 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6251) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6264 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6266 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6264 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6266)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) b)) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align mul_inv_le_iff_le_mul' mul_inv_le_iff_le_mul'ₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_le_iff_le_mul' : a * b⁻¹ ≤ c ↔ a ≤ b * c := by
   rw [← inv_mul_le_iff_le_mul, mul_comm]
 #align mul_inv_le_iff_le_mul' mul_inv_le_iff_le_mul'
 #align add_neg_le_iff_le_add' add_neg_le_iff_le_add'
 
-/- warning: mul_inv_le_mul_inv_iff' -> mul_inv_le_mul_inv_iff' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α} {d : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) d))) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6345 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6347 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6345 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6347) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6360 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6362 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6360 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6362)] {a : α} {b : α} {c : α} {d : α}, Iff (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) d))) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-Case conversion may be inaccurate. Consider using '#align mul_inv_le_mul_inv_iff' mul_inv_le_mul_inv_iff'ₓ'. -/
 @[to_additive add_neg_le_add_neg_iff]
 theorem mul_inv_le_mul_inv_iff' : a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b := by
   rw [mul_comm c, mul_inv_le_inv_mul_iff, mul_comm]
@@ -913,35 +529,17 @@ section LT
 
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
-/- warning: inv_mul_lt_iff_lt_mul' -> inv_mul_lt_iff_lt_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) c) a) b) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6503 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6505 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6503 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6505) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6518 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6520 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6518 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6520)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) c) a) b) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align inv_mul_lt_iff_lt_mul' inv_mul_lt_iff_lt_mul'ₓ'. -/
 @[to_additive]
 theorem inv_mul_lt_iff_lt_mul' : c⁻¹ * a < b ↔ a < b * c := by rw [inv_mul_lt_iff_lt_mul, mul_comm]
 #align inv_mul_lt_iff_lt_mul' inv_mul_lt_iff_lt_mul'
 #align neg_add_lt_iff_lt_add' neg_add_lt_iff_lt_add'
 
-/- warning: mul_inv_lt_iff_le_mul' -> mul_inv_lt_iff_le_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) b)) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6599 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6601 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6599 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6601) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6614 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6616 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6614 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6616)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) b)) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align mul_inv_lt_iff_le_mul' mul_inv_lt_iff_le_mul'ₓ'. -/
 @[simp, to_additive]
 theorem mul_inv_lt_iff_le_mul' : a * b⁻¹ < c ↔ a < b * c := by
   rw [← inv_mul_lt_iff_lt_mul, mul_comm]
 #align mul_inv_lt_iff_le_mul' mul_inv_lt_iff_le_mul'
 #align add_neg_lt_iff_le_add' add_neg_lt_iff_le_add'
 
-/- warning: mul_inv_lt_mul_inv_iff' -> mul_inv_lt_mul_inv_iff' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α} {d : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) d))) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6695 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6697 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6695 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6697) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6710 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6712 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6710 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6712)] {a : α} {b : α} {c : α} {d : α}, Iff (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) b)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) d))) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-Case conversion may be inaccurate. Consider using '#align mul_inv_lt_mul_inv_iff' mul_inv_lt_mul_inv_iff'ₓ'. -/
 @[to_additive add_neg_lt_add_neg_iff]
 theorem mul_inv_lt_mul_inv_iff' : a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b := by
   rw [mul_comm c, mul_inv_lt_inv_mul_iff, mul_comm]
@@ -952,161 +550,71 @@ end LT
 
 end CommGroup
 
-/- warning: one_le_of_inv_le_one -> one_le_of_inv_le_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α}, (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.446 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.448 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.446 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.448) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.461 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.463 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.461 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.463)] {a : α}, (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align one_le_of_inv_le_one one_le_of_inv_le_oneₓ'. -/
 alias Left.inv_le_one_iff ↔ one_le_of_inv_le_one _
 #align one_le_of_inv_le_one one_le_of_inv_le_one
 
 attribute [to_additive] one_le_of_inv_le_one
 
-/- warning: le_one_of_one_le_inv -> le_one_of_one_le_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α}, (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) -> (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.547 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.549 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.547 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.549) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.562 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.564 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.562 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.564)] {a : α}, (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) -> (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align le_one_of_one_le_inv le_one_of_one_le_invₓ'. -/
 alias Left.one_le_inv_iff ↔ le_one_of_one_le_inv _
 #align le_one_of_one_le_inv le_one_of_one_le_inv
 
 attribute [to_additive nonpos_of_neg_nonneg] le_one_of_one_le_inv
 
-/- warning: lt_of_inv_lt_inv -> lt_of_inv_lt_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b)) -> (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4674 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4676 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4674 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4676) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4689 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4691 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4689 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4691)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4711 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4713 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4711 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4713)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4726 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4728 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4726 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4728)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) -> (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align lt_of_inv_lt_inv lt_of_inv_lt_invₓ'. -/
 alias inv_lt_inv_iff ↔ lt_of_inv_lt_inv _
 #align lt_of_inv_lt_inv lt_of_inv_lt_inv
 
 attribute [to_additive] lt_of_inv_lt_inv
 
-/- warning: one_lt_of_inv_lt_one -> one_lt_of_inv_lt_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405)] {a : α}, (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align one_lt_of_inv_lt_one one_lt_of_inv_lt_oneₓ'. -/
 alias Left.inv_lt_one_iff ↔ one_lt_of_inv_lt_one _
 #align one_lt_of_inv_lt_one one_lt_of_inv_lt_one
 
 attribute [to_additive] one_lt_of_inv_lt_one
 
-/- warning: inv_lt_one_iff_one_lt -> inv_lt_one_iff_one_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align inv_lt_one_iff_one_lt inv_lt_one_iff_one_ltₓ'. -/
 alias Left.inv_lt_one_iff ← inv_lt_one_iff_one_lt
 #align inv_lt_one_iff_one_lt inv_lt_one_iff_one_lt
 
 attribute [to_additive] inv_lt_one_iff_one_lt
 
-/- warning: inv_lt_one' -> inv_lt_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1388 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1390) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1403 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1405)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align inv_lt_one' inv_lt_one'ₓ'. -/
 alias Left.inv_lt_one_iff ← inv_lt_one'
 #align inv_lt_one' inv_lt_one'
 
 attribute [to_additive neg_lt_zero] inv_lt_one'
 
-/- warning: inv_of_one_lt_inv -> inv_of_one_lt_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) -> (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308)] {a : α}, (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) -> (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align inv_of_one_lt_inv inv_of_one_lt_invₓ'. -/
 alias Left.one_lt_inv_iff ↔ inv_of_one_lt_inv _
 #align inv_of_one_lt_inv inv_of_one_lt_inv
 
 attribute [to_additive neg_of_neg_pos] inv_of_one_lt_inv
 
-/- warning: one_lt_inv_of_inv -> one_lt_inv_of_inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308)] {a : α}, (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
-Case conversion may be inaccurate. Consider using '#align one_lt_inv_of_inv one_lt_inv_of_invₓ'. -/
 alias Left.one_lt_inv_iff ↔ _ one_lt_inv_of_inv
 #align one_lt_inv_of_inv one_lt_inv_of_inv
 
 attribute [to_additive neg_pos_of_neg] one_lt_inv_of_inv
 
-/- warning: mul_le_of_le_inv_mul -> mul_le_of_le_inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) c)) -> (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c)) -> (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_le_inv_mul mul_le_of_le_inv_mulₓ'. -/
 alias le_inv_mul_iff_mul_le ↔ mul_le_of_le_inv_mul _
 #align mul_le_of_le_inv_mul mul_le_of_le_inv_mul
 
 attribute [to_additive] mul_le_of_le_inv_mul
 
-/- warning: le_inv_mul_of_mul_le -> le_inv_mul_of_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c) -> (LE.le.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c) -> (LE.le.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c))
-Case conversion may be inaccurate. Consider using '#align le_inv_mul_of_mul_le le_inv_mul_of_mul_leₓ'. -/
 alias le_inv_mul_iff_mul_le ↔ _ le_inv_mul_of_mul_le
 #align le_inv_mul_of_mul_le le_inv_mul_of_mul_le
 
 attribute [to_additive] le_inv_mul_of_mul_le
 
-/- warning: inv_mul_le_of_le_mul -> inv_mul_le_of_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c)) -> (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.746 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.748 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.746 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.748) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.761 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.763 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.761 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.763)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c)) -> (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a) c)
-Case conversion may be inaccurate. Consider using '#align inv_mul_le_of_le_mul inv_mul_le_of_le_mulₓ'. -/
 alias inv_mul_le_iff_le_mul ↔ _ inv_mul_le_of_le_mul
 #align inv_mul_le_of_le_mul inv_mul_le_of_le_mul
 
 attribute [to_additive] inv_mul_le_iff_le_mul
 
-/- warning: mul_lt_of_lt_inv_mul -> mul_lt_of_lt_inv_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) c)) -> (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c)) -> (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_inv_mul mul_lt_of_lt_inv_mulₓ'. -/
 alias lt_inv_mul_iff_mul_lt ↔ mul_lt_of_lt_inv_mul _
 #align mul_lt_of_lt_inv_mul mul_lt_of_lt_inv_mul
 
 attribute [to_additive] mul_lt_of_lt_inv_mul
 
-/- warning: lt_inv_mul_of_mul_lt -> lt_inv_mul_of_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c) -> (LT.lt.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c) -> (LT.lt.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c))
-Case conversion may be inaccurate. Consider using '#align lt_inv_mul_of_mul_lt lt_inv_mul_of_mul_ltₓ'. -/
 alias lt_inv_mul_iff_mul_lt ↔ _ lt_inv_mul_of_mul_lt
 #align lt_inv_mul_of_mul_lt lt_inv_mul_of_mul_lt
 
 attribute [to_additive] lt_inv_mul_of_mul_lt
 
-/- warning: lt_mul_of_inv_mul_lt -> lt_mul_of_inv_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a) c) -> (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a) c) -> (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_inv_mul_lt lt_mul_of_inv_mul_ltₓ'. -/
-/- warning: inv_mul_lt_of_lt_mul -> inv_mul_lt_of_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c)) -> (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c)) -> (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a) c)
-Case conversion may be inaccurate. Consider using '#align inv_mul_lt_of_lt_mul inv_mul_lt_of_lt_mulₓ'. -/
 alias inv_mul_lt_iff_lt_mul ↔ lt_mul_of_inv_mul_lt inv_mul_lt_of_lt_mul
 #align lt_mul_of_inv_mul_lt lt_mul_of_inv_mul_lt
 #align inv_mul_lt_of_lt_mul inv_mul_lt_of_lt_mul
@@ -1115,45 +623,21 @@ attribute [to_additive] lt_mul_of_inv_mul_lt
 
 attribute [to_additive] inv_mul_lt_of_lt_mul
 
-/- warning: lt_mul_of_inv_mul_lt_left -> lt_mul_of_inv_mul_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) b) a) c) -> (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1582 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1584) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1597 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1599)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b) a) c) -> (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_inv_mul_lt_left lt_mul_of_inv_mul_lt_leftₓ'. -/
 alias lt_mul_of_inv_mul_lt ← lt_mul_of_inv_mul_lt_left
 #align lt_mul_of_inv_mul_lt_left lt_mul_of_inv_mul_lt_left
 
 attribute [to_additive] lt_mul_of_inv_mul_lt_left
 
-/- warning: inv_le_one' -> inv_le_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.446 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.448 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.446 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.448) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.461 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.463 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.461 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.463)] {a : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a)
-Case conversion may be inaccurate. Consider using '#align inv_le_one' inv_le_one'ₓ'. -/
 alias Left.inv_le_one_iff ← inv_le_one'
 #align inv_le_one' inv_le_one'
 
 attribute [to_additive neg_nonpos] inv_le_one'
 
-/- warning: one_le_inv' -> one_le_inv' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] {a : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.547 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.549 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.547 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.549) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.562 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.564 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.562 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.564)] {a : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (LE.le.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align one_le_inv' one_le_inv'ₓ'. -/
 alias Left.one_le_inv_iff ← one_le_inv'
 #align one_le_inv' one_le_inv'
 
 attribute [to_additive neg_nonneg] one_le_inv'
 
-/- warning: one_lt_inv' -> one_lt_inv' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a)) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1291 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1293) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1306 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1308)] {a : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a)) (LT.lt.{u1} α _inst_2 a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align one_lt_inv' one_lt_inv'ₓ'. -/
 alias Left.one_lt_inv_iff ← one_lt_inv'
 #align one_lt_inv' one_lt_inv'
 
@@ -1186,132 +670,54 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
-/- warning: div_le_div_iff_right -> div_le_div_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} (c : α), Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c)) (LE.le.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6956 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6958 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6956 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6958)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6971 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6973 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6971 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6973)] {a : α} {b : α} (c : α), Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c)) (LE.le.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align div_le_div_iff_right div_le_div_iff_rightₓ'. -/
 @[simp, to_additive]
 theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b := by
   simpa only [div_eq_mul_inv] using mul_le_mul_iff_right _
 #align div_le_div_iff_right div_le_div_iff_right
 #align sub_le_sub_iff_right sub_le_sub_iff_right
 
-/- warning: div_le_div_right' -> div_le_div_right' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a b) -> (forall (c : α), LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7034 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7036 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7034 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7036)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7049 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7051 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7049 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7051)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a b) -> (forall (c : α), LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c))
-Case conversion may be inaccurate. Consider using '#align div_le_div_right' div_le_div_right'ₓ'. -/
 @[to_additive sub_le_sub_right]
 theorem div_le_div_right' (h : a ≤ b) (c : α) : a / c ≤ b / c :=
   (div_le_div_iff_right c).2 h
 #align div_le_div_right' div_le_div_right'
 #align sub_le_sub_right sub_le_sub_right
 
-/- warning: one_le_div' -> one_le_div' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b)) (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7106 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7108 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7106 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7108)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7121 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7123 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7121 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7123)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b)) (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align one_le_div' one_le_div'ₓ'. -/
 @[simp, to_additive sub_nonneg]
 theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_le_div' one_le_div'
 #align sub_nonneg sub_nonneg
 
-/- warning: le_of_sub_nonneg -> le_of_sub_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b)) -> (LE.le.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7106 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7108 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7106 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7108)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7121 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7123 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7121 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7123)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b)) -> (LE.le.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align le_of_sub_nonneg le_of_sub_nonnegₓ'. -/
-/- warning: sub_nonneg_of_le -> sub_nonneg_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 b a) -> (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7106 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7108 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7106 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7108)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7121 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7123 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7121 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7123)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 b a) -> (LE.le.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align sub_nonneg_of_le sub_nonneg_of_leₓ'. -/
 alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
 #align le_of_sub_nonneg le_of_sub_nonneg
 #align sub_nonneg_of_le sub_nonneg_of_le
 
-/- warning: div_le_one' -> div_le_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LE.le.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7207 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7209 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7207 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7209)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7222 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7224 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7222 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7224)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align div_le_one' div_le_one'ₓ'. -/
 @[simp, to_additive sub_nonpos]
 theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_one' div_le_one'
 #align sub_nonpos sub_nonpos
 
-/- warning: le_of_sub_nonpos -> le_of_sub_nonpos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7207 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7209 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7207 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7209)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7222 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7224 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7222 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7224)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1))))))) -> (LE.le.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align le_of_sub_nonpos le_of_sub_nonposₓ'. -/
-/- warning: sub_nonpos_of_le -> sub_nonpos_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a b) -> (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7207 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7209 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7207 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7209)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7222 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7224 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7222 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7224)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a b) -> (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align sub_nonpos_of_le sub_nonpos_of_leₓ'. -/
 alias sub_nonpos ↔ le_of_sub_nonpos sub_nonpos_of_le
 #align le_of_sub_nonpos le_of_sub_nonpos
 #align sub_nonpos_of_le sub_nonpos_of_le
 
-/- warning: le_div_iff_mul_le -> le_div_iff_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7308 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7310 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7308 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7310)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7323 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7325 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7323 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7325)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align le_div_iff_mul_le le_div_iff_mul_leₓ'. -/
 @[to_additive]
 theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c := by
   rw [← mul_le_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
 #align le_div_iff_mul_le le_div_iff_mul_le
 #align le_sub_iff_add_le le_sub_iff_add_le
 
-/- warning: add_le_of_le_sub_right -> add_le_of_le_sub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b)) -> (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7308 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7310 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7308 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7310)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7323 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7325 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7323 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7325)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b)) -> (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align add_le_of_le_sub_right add_le_of_le_sub_rightₓ'. -/
-/- warning: le_sub_right_of_add_le -> le_sub_right_of_add_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c) -> (LE.le.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7308 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7310 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7308 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7310)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7323 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7325 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7323 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7325)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c) -> (LE.le.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b))
-Case conversion may be inaccurate. Consider using '#align le_sub_right_of_add_le le_sub_right_of_add_leₓ'. -/
 alias le_sub_iff_add_le ↔ add_le_of_le_sub_right le_sub_right_of_add_le
 #align add_le_of_le_sub_right add_le_of_le_sub_right
 #align le_sub_right_of_add_le le_sub_right_of_add_le
 
-/- warning: div_le_iff_le_mul -> div_le_iff_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) b) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7410 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7412 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7410 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7412)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7425 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7427 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7425 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7427)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) b) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-Case conversion may be inaccurate. Consider using '#align div_le_iff_le_mul div_le_iff_le_mulₓ'. -/
 @[to_additive]
 theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c := by
   rw [← mul_le_mul_iff_right c, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_iff_le_mul div_le_iff_le_mul
 #align sub_le_iff_le_add sub_le_iff_le_add
 
-/- warning: add_group.to_has_ordered_sub -> AddGroup.toHasOrderedSub is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : AddGroup.{u1} α] [_inst_5 : LE.{u1} α] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_4))))))) (LE.le.{u1} α _inst_5)], OrderedSub.{u1} α _inst_5 (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_4)))) (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_4))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_4 : AddGroup.{u1} α] [_inst_5 : LE.{u1} α] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7560 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7562 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_4))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7560 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7562)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7575 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7577 : α) => LE.le.{u1} α _inst_5 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7575 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7577)], OrderedSub.{u1} α _inst_5 (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_4)))) (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_4))
-Case conversion may be inaccurate. Consider using '#align add_group.to_has_ordered_sub AddGroup.toHasOrderedSubₓ'. -/
 -- TODO: Should we get rid of `sub_le_iff_le_add` in favor of
 -- (a renamed version of) `tsub_le_iff_right`?
 -- see Note [lower instance priority]
@@ -1328,12 +734,6 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
-/- warning: div_le_div_iff_left -> div_le_div_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {b : α} {c : α} (a : α), Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c)) (LE.le.{u1} α _inst_2 c b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7748 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7750 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7748 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7750) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7763 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7765 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7763 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7765)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7785 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7787 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7785 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7787)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7800 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7802 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7800 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7802)] {b : α} {c : α} (a : α), Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c)) (LE.le.{u1} α _inst_2 c b)
-Case conversion may be inaccurate. Consider using '#align div_le_div_iff_left div_le_div_iff_leftₓ'. -/
 @[simp, to_additive]
 theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_le_mul_iff_left a⁻¹, inv_mul_cancel_left,
@@ -1341,12 +741,6 @@ theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b := by
 #align div_le_div_iff_left div_le_div_iff_left
 #align sub_le_sub_iff_left sub_le_sub_iff_left
 
-/- warning: div_le_div_left' -> div_le_div_left' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a b) -> (forall (c : α), LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7887 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7889 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7887 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7889) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7902 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7904 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7902 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7904)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7924 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7926 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7924 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7926)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7939 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7941 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7939 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.7941)] {a : α} {b : α}, (LE.le.{u1} α _inst_2 a b) -> (forall (c : α), LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c a))
-Case conversion may be inaccurate. Consider using '#align div_le_div_left' div_le_div_left'ₓ'. -/
 @[to_additive sub_le_sub_left]
 theorem div_le_div_left' (h : a ≤ b) (c : α) : c / b ≤ c / a :=
   (div_le_div_iff_left c).2 h
@@ -1365,113 +759,47 @@ section LE
 
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
-/- warning: div_le_div_iff' -> div_le_div_iff' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α} {d : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c d)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8054 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8056 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8054 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8056) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8069 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8071 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8069 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8071)] {a : α} {b : α} {c : α} {d : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c d)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-Case conversion may be inaccurate. Consider using '#align div_le_div_iff' div_le_div_iff'ₓ'. -/
 @[to_additive sub_le_sub_iff]
 theorem div_le_div_iff' : a / b ≤ c / d ↔ a * d ≤ c * b := by
   simpa only [div_eq_mul_inv] using mul_inv_le_mul_inv_iff'
 #align div_le_div_iff' div_le_div_iff'
 #align sub_le_sub_iff sub_le_sub_iff
 
-/- warning: le_div_iff_mul_le' -> le_div_iff_mul_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 b (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c a)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8131 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8133 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8131 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8133) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8146 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8148 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8146 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8148)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 b (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c a)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align le_div_iff_mul_le' le_div_iff_mul_le'ₓ'. -/
 @[to_additive]
 theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c := by rw [le_div_iff_mul_le, mul_comm]
 #align le_div_iff_mul_le' le_div_iff_mul_le'
 #align le_sub_iff_add_le' le_sub_iff_add_le'
 
-/- warning: add_le_of_le_sub_left -> add_le_of_le_sub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a)) -> (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8131 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8133 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8131 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8133) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8146 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8148 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8146 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8148)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a)) -> (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align add_le_of_le_sub_left add_le_of_le_sub_leftₓ'. -/
-/- warning: le_sub_left_of_add_le -> le_sub_left_of_add_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c) -> (LE.le.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8131 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8133 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8131 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8133) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8146 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8148 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8146 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8148)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c) -> (LE.le.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a))
-Case conversion may be inaccurate. Consider using '#align le_sub_left_of_add_le le_sub_left_of_add_leₓ'. -/
 alias le_sub_iff_add_le' ↔ add_le_of_le_sub_left le_sub_left_of_add_le
 #align add_le_of_le_sub_left add_le_of_le_sub_left
 #align le_sub_left_of_add_le le_sub_left_of_add_le
 
-/- warning: div_le_iff_le_mul' -> div_le_iff_le_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8228 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8230 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8228 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8230) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8243 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8245 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8243 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8245)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LE.le.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align div_le_iff_le_mul' div_le_iff_le_mul'ₓ'. -/
 @[to_additive]
 theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le_mul, mul_comm]
 #align div_le_iff_le_mul' div_le_iff_le_mul'
 #align sub_le_iff_le_add' sub_le_iff_le_add'
 
-/- warning: le_add_of_sub_left_le -> le_add_of_sub_left_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) -> (LE.le.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8228 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8230 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8228 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8230) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8243 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8245 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8243 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8245)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) -> (LE.le.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align le_add_of_sub_left_le le_add_of_sub_left_leₓ'. -/
-/- warning: sub_left_le_of_le_add -> sub_left_le_of_le_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8228 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8230 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8228 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8230) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8243 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8245 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8243 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8245)] {a : α} {b : α} {c : α}, (LE.le.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (LE.le.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c)
-Case conversion may be inaccurate. Consider using '#align sub_left_le_of_le_add sub_left_le_of_le_addₓ'. -/
 alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
 #align le_add_of_sub_left_le le_add_of_sub_left_le
 #align sub_left_le_of_le_add sub_left_le_of_le_add
 
-/- warning: inv_le_div_iff_le_mul -> inv_le_div_iff_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c)) (LE.le.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8325 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8327 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8325 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8327) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8340 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8342 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8340 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8342)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c)) (LE.le.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b))
-Case conversion may be inaccurate. Consider using '#align inv_le_div_iff_le_mul inv_le_div_iff_le_mulₓ'. -/
 @[simp, to_additive]
 theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b :=
   le_div_iff_mul_le.trans inv_mul_le_iff_le_mul'
 #align inv_le_div_iff_le_mul inv_le_div_iff_le_mul
 #align neg_le_sub_iff_le_add neg_le_sub_iff_le_add
 
-/- warning: inv_le_div_iff_le_mul' -> inv_le_div_iff_le_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) a) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c)) (LE.le.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8394 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8396 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8394 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8396) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8409 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8411 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8409 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8411)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) a) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c)) (LE.le.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b))
-Case conversion may be inaccurate. Consider using '#align inv_le_div_iff_le_mul' inv_le_div_iff_le_mul'ₓ'. -/
 @[to_additive]
 theorem inv_le_div_iff_le_mul' : a⁻¹ ≤ b / c ↔ c ≤ a * b := by rw [inv_le_div_iff_le_mul, mul_comm]
 #align inv_le_div_iff_le_mul' inv_le_div_iff_le_mul'
 #align neg_le_sub_iff_le_add' neg_le_sub_iff_le_add'
 
-/- warning: div_le_comm -> div_le_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8490 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8492 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8490 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8492) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8505 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8507 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8505 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8507)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LE.le.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c) b)
-Case conversion may be inaccurate. Consider using '#align div_le_comm div_le_commₓ'. -/
 @[to_additive]
 theorem div_le_comm : a / b ≤ c ↔ a / c ≤ b :=
   div_le_iff_le_mul'.trans div_le_iff_le_mul.symm
 #align div_le_comm div_le_comm
 #align sub_le_comm sub_le_comm
 
-/- warning: le_div_comm -> le_div_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c)) (LE.le.{u1} α _inst_2 c (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8557 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8559 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8557 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8559) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8572 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8574 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8572 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8574)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c)) (LE.le.{u1} α _inst_2 c (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b a))
-Case conversion may be inaccurate. Consider using '#align le_div_comm le_div_commₓ'. -/
 @[to_additive]
 theorem le_div_comm : a ≤ b / c ↔ c ≤ b / a :=
   le_div_iff_mul_le'.trans le_div_iff_mul_le.symm
@@ -1484,12 +812,6 @@ section Preorder
 
 variable [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
-/- warning: div_le_div'' -> div_le_div'' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α} {b : α} {c : α} {d : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8678 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8680 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8678 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8680) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8693 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8695 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8693 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8695)] {a : α} {b : α} {c : α} {d : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
-Case conversion may be inaccurate. Consider using '#align div_le_div'' div_le_div''ₓ'. -/
 @[to_additive sub_le_sub]
 theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c :=
   by
@@ -1512,147 +834,57 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c d : α}
 
-/- warning: div_lt_div_iff_right -> div_lt_div_iff_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} (c : α), Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c)) (LT.lt.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8857 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8859 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8857 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8859)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8872 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8874 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8872 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8874)] {a : α} {b : α} (c : α), Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c)) (LT.lt.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align div_lt_div_iff_right div_lt_div_iff_rightₓ'. -/
 @[simp, to_additive]
 theorem div_lt_div_iff_right (c : α) : a / c < b / c ↔ a < b := by
   simpa only [div_eq_mul_inv] using mul_lt_mul_iff_right _
 #align div_lt_div_iff_right div_lt_div_iff_right
 #align sub_lt_sub_iff_right sub_lt_sub_iff_right
 
-/- warning: div_lt_div_right' -> div_lt_div_right' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a b) -> (forall (c : α), LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8935 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8937 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8935 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8937)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8950 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8952 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8950 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8952)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a b) -> (forall (c : α), LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c))
-Case conversion may be inaccurate. Consider using '#align div_lt_div_right' div_lt_div_right'ₓ'. -/
 @[to_additive sub_lt_sub_right]
 theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c :=
   (div_lt_div_iff_right c).2 h
 #align div_lt_div_right' div_lt_div_right'
 #align sub_lt_sub_right sub_lt_sub_right
 
-/- warning: one_lt_div' -> one_lt_div' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b)) (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9007 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9009 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9007 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9009)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9022 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9024 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9022 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9024)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b)) (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align one_lt_div' one_lt_div'ₓ'. -/
 @[simp, to_additive sub_pos]
 theorem one_lt_div' : 1 < a / b ↔ b < a := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_lt_div' one_lt_div'
 #align sub_pos sub_pos
 
-/- warning: lt_of_sub_pos -> lt_of_sub_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b)) -> (LT.lt.{u1} α _inst_2 b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9007 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9009 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9007 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9009)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9022 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9024 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9022 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9024)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b)) -> (LT.lt.{u1} α _inst_2 b a)
-Case conversion may be inaccurate. Consider using '#align lt_of_sub_pos lt_of_sub_posₓ'. -/
-/- warning: sub_pos_of_lt -> sub_pos_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 b a) -> (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9007 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9009 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9007 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9009)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9022 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9024 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9022 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9024)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 b a) -> (LT.lt.{u1} α _inst_2 (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b))
-Case conversion may be inaccurate. Consider using '#align sub_pos_of_lt sub_pos_of_ltₓ'. -/
 alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
 #align lt_of_sub_pos lt_of_sub_pos
 #align sub_pos_of_lt sub_pos_of_lt
 
-/- warning: div_lt_one' -> div_lt_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align div_lt_one' div_lt_one'ₓ'. -/
 @[simp, to_additive sub_neg]
 theorem div_lt_one' : a / b < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_one' div_lt_one'
 #align sub_neg sub_neg
 
-/- warning: lt_of_sub_neg -> lt_of_sub_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1))))))) -> (LT.lt.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align lt_of_sub_neg lt_of_sub_negₓ'. -/
-/- warning: sub_neg_of_lt -> sub_neg_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a b) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a b) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))))
-Case conversion may be inaccurate. Consider using '#align sub_neg_of_lt sub_neg_of_ltₓ'. -/
 alias sub_neg ↔ lt_of_sub_neg sub_neg_of_lt
 #align lt_of_sub_neg lt_of_sub_neg
 #align sub_neg_of_lt sub_neg_of_lt
 
-/- warning: sub_lt_zero -> sub_lt_zero is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))))) (LT.lt.{u1} α _inst_2 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9108 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9110)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9123 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9125)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2 a b)
-Case conversion may be inaccurate. Consider using '#align sub_lt_zero sub_lt_zeroₓ'. -/
 alias sub_neg ← sub_lt_zero
 #align sub_lt_zero sub_lt_zero
 
-/- warning: lt_div_iff_mul_lt -> lt_div_iff_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9211 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9213 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9211 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9213)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9226 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9228 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9226 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9228)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align lt_div_iff_mul_lt lt_div_iff_mul_ltₓ'. -/
 @[to_additive]
 theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c := by
   rw [← mul_lt_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
 #align lt_div_iff_mul_lt lt_div_iff_mul_lt
 #align lt_sub_iff_add_lt lt_sub_iff_add_lt
 
-/- warning: add_lt_of_lt_sub_right -> add_lt_of_lt_sub_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b)) -> (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9211 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9213 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9211 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9213)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9226 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9228 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9226 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9228)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b)) -> (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align add_lt_of_lt_sub_right add_lt_of_lt_sub_rightₓ'. -/
-/- warning: lt_sub_right_of_add_lt -> lt_sub_right_of_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c) -> (LT.lt.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9211 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9213 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9211 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9213)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9226 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9228 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9226 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9228)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) a b) c) -> (LT.lt.{u1} α _inst_2 a (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) c b))
-Case conversion may be inaccurate. Consider using '#align lt_sub_right_of_add_lt lt_sub_right_of_add_ltₓ'. -/
 alias lt_sub_iff_add_lt ↔ add_lt_of_lt_sub_right lt_sub_right_of_add_lt
 #align add_lt_of_lt_sub_right add_lt_of_lt_sub_right
 #align lt_sub_right_of_add_lt lt_sub_right_of_add_lt
 
-/- warning: div_lt_iff_lt_mul -> div_lt_iff_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) b) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9313 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9315 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9313 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9315)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9328 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9330 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9328 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9330)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c) b) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b c))
-Case conversion may be inaccurate. Consider using '#align div_lt_iff_lt_mul div_lt_iff_lt_mulₓ'. -/
 @[to_additive]
 theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c := by
   rw [← mul_lt_mul_iff_right c, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_iff_lt_mul div_lt_iff_lt_mul
 #align sub_lt_iff_lt_add sub_lt_iff_lt_add
 
-/- warning: lt_add_of_sub_right_lt -> lt_add_of_sub_right_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a c) b) -> (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9313 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9315 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9313 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9315)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9328 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9330 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9328 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9330)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a c) b) -> (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) b c))
-Case conversion may be inaccurate. Consider using '#align lt_add_of_sub_right_lt lt_add_of_sub_right_ltₓ'. -/
-/- warning: sub_right_lt_of_lt_add -> sub_right_lt_of_lt_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) b c)) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9313 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9315 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9313 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9315)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9328 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9330 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9328 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9330)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) b c)) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))) a c) b)
-Case conversion may be inaccurate. Consider using '#align sub_right_lt_of_lt_add sub_right_lt_of_lt_addₓ'. -/
 alias sub_lt_iff_lt_add ↔ lt_add_of_sub_right_lt sub_right_lt_of_lt_add
 #align lt_add_of_sub_right_lt lt_add_of_sub_right_lt
 #align sub_right_lt_of_lt_add sub_right_lt_of_lt_add
@@ -1664,12 +896,6 @@ section Left
 variable [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (swap (· * ·)) (· < ·)]
   {a b c : α}
 
-/- warning: div_lt_div_iff_left -> div_lt_div_iff_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {b : α} {c : α} (a : α), Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c)) (LT.lt.{u1} α _inst_2 c b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9501 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9503 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9501 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9503) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9516 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9518 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9516 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9518)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9538 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9540 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9538 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9540)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9553 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9555 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9553 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9555)] {b : α} {c : α} (a : α), Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a c)) (LT.lt.{u1} α _inst_2 c b)
-Case conversion may be inaccurate. Consider using '#align div_lt_div_iff_left div_lt_div_iff_leftₓ'. -/
 @[simp, to_additive]
 theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_lt_mul_iff_left a⁻¹, inv_mul_cancel_left,
@@ -1677,24 +903,12 @@ theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b := by
 #align div_lt_div_iff_left div_lt_div_iff_left
 #align sub_lt_sub_iff_left sub_lt_sub_iff_left
 
-/- warning: inv_lt_div_iff_lt_mul -> inv_lt_div_iff_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c)) (LT.lt.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9640 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9642 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9640 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9642) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9655 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9657 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9655 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9657)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9677 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9679 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9677 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9679)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9692 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9694 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9692 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9694)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) b c)) (LT.lt.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b))
-Case conversion may be inaccurate. Consider using '#align inv_lt_div_iff_lt_mul inv_lt_div_iff_lt_mulₓ'. -/
 @[simp, to_additive]
 theorem inv_lt_div_iff_lt_mul : a⁻¹ < b / c ↔ c < a * b := by
   rw [div_eq_mul_inv, lt_mul_inv_iff_mul_lt, inv_mul_lt_iff_lt_mul]
 #align inv_lt_div_iff_lt_mul inv_lt_div_iff_lt_mul
 #align neg_lt_sub_iff_lt_add neg_lt_sub_iff_lt_add
 
-/- warning: div_lt_div_left' -> div_lt_div_left' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α _inst_2)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a b) -> (forall (c : α), LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9773 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9775 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9773 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9775) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9788 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9790 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9788 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9790)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9810 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9812 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9810 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9812)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9825 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9827 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9825 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9827)] {a : α} {b : α}, (LT.lt.{u1} α _inst_2 a b) -> (forall (c : α), LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) c a))
-Case conversion may be inaccurate. Consider using '#align div_lt_div_left' div_lt_div_left'ₓ'. -/
 @[to_additive sub_lt_sub_left]
 theorem div_lt_div_left' (h : a < b) (c : α) : c / b < c / a :=
   (div_lt_div_iff_left c).2 h
@@ -1713,102 +927,42 @@ section LT
 
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
-/- warning: div_lt_div_iff' -> div_lt_div_iff' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α} {d : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c d)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9940 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9942 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9940 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9942) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9955 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9957 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9955 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.9957)] {a : α} {b : α} {c : α} {d : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c d)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a d) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) c b))
-Case conversion may be inaccurate. Consider using '#align div_lt_div_iff' div_lt_div_iff'ₓ'. -/
 @[to_additive sub_lt_sub_iff]
 theorem div_lt_div_iff' : a / b < c / d ↔ a * d < c * b := by
   simpa only [div_eq_mul_inv] using mul_inv_lt_mul_inv_iff'
 #align div_lt_div_iff' div_lt_div_iff'
 #align sub_lt_sub_iff sub_lt_sub_iff
 
-/- warning: lt_div_iff_mul_lt' -> lt_div_iff_mul_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 b (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c a)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10017 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10019 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10017 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10019) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10032 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10034 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10032 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10034)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 b (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) c a)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align lt_div_iff_mul_lt' lt_div_iff_mul_lt'ₓ'. -/
 @[to_additive]
 theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c := by rw [lt_div_iff_mul_lt, mul_comm]
 #align lt_div_iff_mul_lt' lt_div_iff_mul_lt'
 #align lt_sub_iff_add_lt' lt_sub_iff_add_lt'
 
-/- warning: add_lt_of_lt_sub_left -> add_lt_of_lt_sub_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a)) -> (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10017 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10019 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10017 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10019) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10032 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10034 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10032 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10034)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a)) -> (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c)
-Case conversion may be inaccurate. Consider using '#align add_lt_of_lt_sub_left add_lt_of_lt_sub_leftₓ'. -/
-/- warning: lt_sub_left_of_add_lt -> lt_sub_left_of_add_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c) -> (LT.lt.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10017 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10019 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10017 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10019) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10032 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10034 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10032 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10034)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) a b) c) -> (LT.lt.{u1} α _inst_2 b (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) c a))
-Case conversion may be inaccurate. Consider using '#align lt_sub_left_of_add_lt lt_sub_left_of_add_ltₓ'. -/
 alias lt_sub_iff_add_lt' ↔ add_lt_of_lt_sub_left lt_sub_left_of_add_lt
 #align add_lt_of_lt_sub_left add_lt_of_lt_sub_left
 #align lt_sub_left_of_add_lt lt_sub_left_of_add_lt
 
-/- warning: div_lt_iff_lt_mul' -> div_lt_iff_lt_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10114 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10116 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10114 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10116) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10129 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10131 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10129 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10131)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LT.lt.{u1} α _inst_2 a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align div_lt_iff_lt_mul' div_lt_iff_lt_mul'ₓ'. -/
 @[to_additive]
 theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c := by rw [div_lt_iff_lt_mul, mul_comm]
 #align div_lt_iff_lt_mul' div_lt_iff_lt_mul'
 #align sub_lt_iff_lt_add' sub_lt_iff_lt_add'
 
-/- warning: lt_add_of_sub_left_lt -> lt_add_of_sub_left_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) -> (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10114 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10116 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10114 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10116) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10129 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10131 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10129 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10131)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c) -> (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c))
-Case conversion may be inaccurate. Consider using '#align lt_add_of_sub_left_lt lt_add_of_sub_left_ltₓ'. -/
-/- warning: sub_left_lt_of_lt_add -> sub_left_lt_of_lt_add is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toHasSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : AddCommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10114 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10116 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10114 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10116) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10129 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10131 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10129 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10131)] {a : α} {b : α} {c : α}, (LT.lt.{u1} α _inst_2 a (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))))) b c)) -> (LT.lt.{u1} α _inst_2 (HSub.hSub.{u1, u1, u1} α α α (instHSub.{u1} α (SubNegMonoid.toSub.{u1} α (AddGroup.toSubNegMonoid.{u1} α (AddCommGroup.toAddGroup.{u1} α _inst_1)))) a b) c)
-Case conversion may be inaccurate. Consider using '#align sub_left_lt_of_lt_add sub_left_lt_of_lt_addₓ'. -/
 alias sub_lt_iff_lt_add' ↔ lt_add_of_sub_left_lt sub_left_lt_of_lt_add
 #align lt_add_of_sub_left_lt lt_add_of_sub_left_lt
 #align sub_left_lt_of_lt_add sub_left_lt_of_lt_add
 
-/- warning: inv_lt_div_iff_lt_mul' -> inv_lt_div_iff_lt_mul' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))) b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c)) (LT.lt.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10211 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10213 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10211 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10213) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10226 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10228 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10226 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10228)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α _inst_1))))) b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c)) (LT.lt.{u1} α _inst_2 c (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) a b))
-Case conversion may be inaccurate. Consider using '#align inv_lt_div_iff_lt_mul' inv_lt_div_iff_lt_mul'ₓ'. -/
 @[to_additive]
 theorem inv_lt_div_iff_lt_mul' : b⁻¹ < a / c ↔ c < a * b :=
   lt_div_iff_mul_lt.trans inv_mul_lt_iff_lt_mul'
 #align inv_lt_div_iff_lt_mul' inv_lt_div_iff_lt_mul'
 #align neg_lt_sub_iff_lt_add' neg_lt_sub_iff_lt_add'
 
-/- warning: div_lt_comm -> div_lt_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10280 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10282 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10280 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10282) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10295 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10297 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10295 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10297)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a b) c) (LT.lt.{u1} α _inst_2 (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a c) b)
-Case conversion may be inaccurate. Consider using '#align div_lt_comm div_lt_commₓ'. -/
 @[to_additive]
 theorem div_lt_comm : a / b < c ↔ a / c < b :=
   div_lt_iff_lt_mul'.trans div_lt_iff_lt_mul.symm
 #align div_lt_comm div_lt_comm
 #align sub_lt_comm sub_lt_comm
 
-/- warning: lt_div_comm -> lt_div_comm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α _inst_2)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c)) (LT.lt.{u1} α _inst_2 c (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10347 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10349 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10347 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10349) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10362 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10364 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10362 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10364)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 a (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c)) (LT.lt.{u1} α _inst_2 c (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b a))
-Case conversion may be inaccurate. Consider using '#align lt_div_comm lt_div_commₓ'. -/
 @[to_additive]
 theorem lt_div_comm : a < b / c ↔ c < b / a :=
   lt_div_iff_mul_lt'.trans lt_div_iff_mul_lt.symm
@@ -1821,12 +975,6 @@ section Preorder
 
 variable [Preorder α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
-/- warning: div_lt_div'' -> div_lt_div'' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α} {b : α} {c : α} {d : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10468 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10470 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10468 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10470) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10483 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10485 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10483 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10485)] {a : α} {b : α} {c : α} {d : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
-Case conversion may be inaccurate. Consider using '#align div_lt_div'' div_lt_div''ₓ'. -/
 @[to_additive sub_lt_sub]
 theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c :=
   by
@@ -1843,12 +991,6 @@ section LinearOrder
 
 variable [Group α] [LinearOrder α]
 
-/- warning: cmp_div_one' -> cmp_div_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] (a : α) (b : α), Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_2 a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_2 a b) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10592 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10594 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10592 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10594)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10607 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10609 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10607 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10609)] (a : α) (b : α), Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_2 a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_2 a b) a b)
-Case conversion may be inaccurate. Consider using '#align cmp_div_one' cmp_div_one'ₓ'. -/
 @[simp, to_additive cmp_sub_zero]
 theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
     cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel']
@@ -1861,36 +1003,18 @@ section VariableNames
 
 variable {a b c : α}
 
-/- warning: le_of_forall_one_lt_lt_mul -> le_of_forall_one_lt_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α}, (forall (ε : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) ε) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10779 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10781 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10779 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10781) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10794 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10796 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10794 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10796)] {a : α} {b : α}, (forall (ε : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) ε) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a b)
-Case conversion may be inaccurate. Consider using '#align le_of_forall_one_lt_lt_mul le_of_forall_one_lt_lt_mulₓ'. -/
 @[to_additive]
 theorem le_of_forall_one_lt_lt_mul (h : ∀ ε : α, 1 < ε → a < b * ε) : a ≤ b :=
   le_of_not_lt fun h₁ => lt_irrefl a (by simpa using h _ (lt_inv_mul_iff_lt.mpr h₁))
 #align le_of_forall_one_lt_lt_mul le_of_forall_one_lt_lt_mul
 #align le_of_forall_pos_lt_add le_of_forall_pos_lt_add
 
-/- warning: le_iff_forall_one_lt_lt_mul -> le_iff_forall_one_lt_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b) (forall (ε : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) ε) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10868 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10870 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10868 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10870) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10883 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10885 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10883 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10885)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a b) (forall (ε : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) ε) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε)))
-Case conversion may be inaccurate. Consider using '#align le_iff_forall_one_lt_lt_mul le_iff_forall_one_lt_lt_mulₓ'. -/
 @[to_additive]
 theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε :=
   ⟨fun h ε => lt_mul_of_le_of_one_lt h, le_of_forall_one_lt_lt_mul⟩
 #align le_iff_forall_one_lt_lt_mul le_iff_forall_one_lt_lt_mul
 #align le_iff_forall_pos_lt_add le_iff_forall_pos_lt_add
 
-/- warning: div_le_inv_mul_iff -> div_le_inv_mul_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α} [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10949 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10951 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10949 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10951) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10964 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10966 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10964 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10966)] {a : α} {b : α} [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10989 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10991 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10989 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10991)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11004 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11006 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11004 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11006)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a b)
-Case conversion may be inaccurate. Consider using '#align div_le_inv_mul_iff div_le_inv_mul_iffₓ'. -/
 /-  I (DT) introduced this lemma to prove (the additive version `sub_le_sub_flip` of)
 `div_le_div_flip` below.  Now I wonder what is the point of either of these lemmas... -/
 @[to_additive]
@@ -1903,12 +1027,6 @@ theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
 #align div_le_inv_mul_iff div_le_inv_mul_iff
 #align sub_le_neg_add_iff sub_le_neg_add_iff
 
-/- warning: div_le_div_flip -> div_le_div_flip is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : CommGroup.{u1} α] [_inst_5 : LinearOrder.{u1} α] [_inst_6 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))))] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) b a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_4 : CommGroup.{u1} α] [_inst_5 : LinearOrder.{u1} α] [_inst_6 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11152 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11154 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11152 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11154) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11167 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11169 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_5)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11167 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11169)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_5)))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) b a)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_5)))))) a b)
-Case conversion may be inaccurate. Consider using '#align div_le_div_flip div_le_div_flipₓ'. -/
 --  What is the point of this lemma?  See comment about `div_le_inv_mul_iff` above.
 @[simp, to_additive]
 theorem div_le_div_flip {α : Type _} [CommGroup α] [LinearOrder α]
@@ -1962,24 +1080,12 @@ section LinearOrderedCommGroup
 
 variable [LinearOrderedCommGroup α] {a b c : α}
 
-/- warning: linear_ordered_comm_group.mul_lt_mul_left' -> LinearOrderedCommGroup.mul_lt_mul_left' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] (a : α) (b : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) a b) -> (forall (c : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] (a : α) (b : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) a b) -> (forall (c : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c b))
-Case conversion may be inaccurate. Consider using '#align linear_ordered_comm_group.mul_lt_mul_left' LinearOrderedCommGroup.mul_lt_mul_left'ₓ'. -/
 @[to_additive LinearOrderedAddCommGroup.add_lt_add_left]
 theorem LinearOrderedCommGroup.mul_lt_mul_left' (a b : α) (h : a < b) (c : α) : c * a < c * b :=
   mul_lt_mul_left' h c
 #align linear_ordered_comm_group.mul_lt_mul_left' LinearOrderedCommGroup.mul_lt_mul_left'
 #align linear_ordered_add_comm_group.add_lt_add_left LinearOrderedAddCommGroup.add_lt_add_left
 
-/- warning: eq_one_of_inv_eq' -> eq_one_of_inv_eq' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] {a : α}, (Eq.{succ u1} α (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))) a) a) -> (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] {a : α}, (Eq.{succ u1} α (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))))) a) a) -> (Eq.{succ u1} α a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))))))))
-Case conversion may be inaccurate. Consider using '#align eq_one_of_inv_eq' eq_one_of_inv_eq'ₓ'. -/
 @[to_additive eq_zero_of_neg_eq]
 theorem eq_one_of_inv_eq' (h : a⁻¹ = a) : a = 1 :=
   match lt_trichotomy a 1 with
@@ -1993,12 +1099,6 @@ theorem eq_one_of_inv_eq' (h : a⁻¹ = a) : a = 1 :=
 #align eq_one_of_inv_eq' eq_one_of_inv_eq'
 #align eq_zero_of_neg_eq eq_zero_of_neg_eq
 
-/- warning: exists_one_lt' -> exists_one_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], Exists.{succ u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))))) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], Exists.{succ u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))))))) a)
-Case conversion may be inaccurate. Consider using '#align exists_one_lt' exists_one_lt'ₓ'. -/
 @[to_additive exists_zero_lt]
 theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a :=
   by
@@ -2009,12 +1109,6 @@ theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a :=
 #align exists_one_lt' exists_one_lt'
 #align exists_zero_lt exists_zero_lt
 
-/- warning: linear_ordered_comm_group.to_no_max_order -> LinearOrderedCommGroup.to_noMaxOrder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align linear_ordered_comm_group.to_no_max_order LinearOrderedCommGroup.to_noMaxOrderₓ'. -/
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LinearOrderedCommGroup.to_noMaxOrder [Nontrivial α] : NoMaxOrder α :=
@@ -2024,12 +1118,6 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMaxOrder [Nontrivial α]
 #align linear_ordered_comm_group.to_no_max_order LinearOrderedCommGroup.to_noMaxOrder
 #align linear_ordered_add_comm_group.to_no_max_order LinearOrderedAddCommGroup.to_noMaxOrder
 
-/- warning: linear_ordered_comm_group.to_no_min_order -> LinearOrderedCommGroup.to_noMinOrder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align linear_ordered_comm_group.to_no_min_order LinearOrderedCommGroup.to_noMinOrderₓ'. -/
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LinearOrderedCommGroup.to_noMinOrder [Nontrivial α] : NoMinOrder α :=
@@ -2135,36 +1223,18 @@ section NormNumLemmas
 expected signatures.  -/
 variable [OrderedCommGroup α] {a b : α}
 
-/- warning: inv_le_inv' -> inv_le_inv' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) b) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a))
-Case conversion may be inaccurate. Consider using '#align inv_le_inv' inv_le_inv'ₓ'. -/
 @[to_additive neg_le_neg]
 theorem inv_le_inv' : a ≤ b → b⁻¹ ≤ a⁻¹ :=
   inv_le_inv_iff.mpr
 #align inv_le_inv' inv_le_inv'
 #align neg_le_neg neg_le_neg
 
-/- warning: inv_lt_inv' -> inv_lt_inv' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) b) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a))
-Case conversion may be inaccurate. Consider using '#align inv_lt_inv' inv_lt_inv'ₓ'. -/
 @[to_additive neg_lt_neg]
 theorem inv_lt_inv' : a < b → b⁻¹ < a⁻¹ :=
   inv_lt_inv_iff.mpr
 #align inv_lt_inv' inv_lt_inv'
 #align neg_lt_neg neg_lt_neg
 
-/- warning: inv_lt_one_of_one_lt -> inv_lt_one_of_one_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align inv_lt_one_of_one_lt inv_lt_one_of_one_ltₓ'. -/
 --  The additive version is also a `linarith` lemma.
 @[to_additive]
 theorem inv_lt_one_of_one_lt : 1 < a → a⁻¹ < 1 :=
@@ -2172,12 +1242,6 @@ theorem inv_lt_one_of_one_lt : 1 < a → a⁻¹ < 1 :=
 #align inv_lt_one_of_one_lt inv_lt_one_of_one_lt
 #align neg_neg_of_pos neg_neg_of_pos
 
-/- warning: inv_le_one_of_one_le -> inv_le_one_of_one_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))))
-Case conversion may be inaccurate. Consider using '#align inv_le_one_of_one_le inv_le_one_of_one_leₓ'. -/
 --  The additive version is also a `linarith` lemma.
 @[to_additive]
 theorem inv_le_one_of_one_le : 1 ≤ a → a⁻¹ ≤ 1 :=
@@ -2185,12 +1249,6 @@ theorem inv_le_one_of_one_le : 1 ≤ a → a⁻¹ ≤ 1 :=
 #align inv_le_one_of_one_le inv_le_one_of_one_le
 #align neg_nonpos_of_nonneg neg_nonpos_of_nonneg
 
-/- warning: one_le_inv_of_le_one -> one_le_inv_of_le_one is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a))
-Case conversion may be inaccurate. Consider using '#align one_le_inv_of_le_one one_le_inv_of_le_oneₓ'. -/
 @[to_additive neg_nonneg_of_nonpos]
 theorem one_le_inv_of_le_one : a ≤ 1 → 1 ≤ a⁻¹ :=
   one_le_inv'.mpr
@@ -2204,48 +1262,24 @@ section
 variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)]
   [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [Preorder β] {f : β → α} {s : Set β}
 
-/- warning: monotone.inv -> Monotone.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Monotone.{u2, u1} β α _inst_5 _inst_2 f) -> (Antitone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12593 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12593) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12608 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12608)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12630 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12630)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12645 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12645)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
-Case conversion may be inaccurate. Consider using '#align monotone.inv Monotone.invₓ'. -/
 @[to_additive]
 theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y hxy =>
   inv_le_inv_iff.2 (hf hxy)
 #align monotone.inv Monotone.inv
 #align monotone.neg Monotone.neg
 
-/- warning: antitone.inv -> Antitone.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Antitone.{u2, u1} β α _inst_5 _inst_2 f) -> (Monotone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12712 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12712) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12727 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12727)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12749 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12749)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12764 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12764)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
-Case conversion may be inaccurate. Consider using '#align antitone.inv Antitone.invₓ'. -/
 @[to_additive]
 theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y hxy =>
   inv_le_inv_iff.2 (hf hxy)
 #align antitone.inv Antitone.inv
 #align antitone.neg Antitone.neg
 
-/- warning: monotone_on.inv -> MonotoneOn.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12831 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12831) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12846 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12846)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12868 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12868)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12883 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12883)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
-Case conversion may be inaccurate. Consider using '#align monotone_on.inv MonotoneOn.invₓ'. -/
 @[to_additive]
 theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_le_inv_iff.2 (hf hx hy hxy)
 #align monotone_on.inv MonotoneOn.inv
 #align monotone_on.neg MonotoneOn.neg
 
-/- warning: antitone_on.inv -> AntitoneOn.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12958 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12958) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12973 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12973)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12995 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12995)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13010 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13010)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
-Case conversion may be inaccurate. Consider using '#align antitone_on.inv AntitoneOn.invₓ'. -/
 @[to_additive]
 theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_le_inv_iff.2 (hf hx hy hxy)
@@ -2259,48 +1293,24 @@ section
 variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· < ·)]
   [CovariantClass α α (swap (· * ·)) (· < ·)] [Preorder β] {f : β → α} {s : Set β}
 
-/- warning: strict_mono.inv -> StrictMono.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictMono.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictAnti.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13183 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13183) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13198 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13198)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13220 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13220)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13235 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13235)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
-Case conversion may be inaccurate. Consider using '#align strict_mono.inv StrictMono.invₓ'. -/
 @[to_additive]
 theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := fun x y hxy =>
   inv_lt_inv_iff.2 (hf hxy)
 #align strict_mono.inv StrictMono.inv
 #align strict_mono.neg StrictMono.neg
 
-/- warning: strict_anti.inv -> StrictAnti.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictAnti.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictMono.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13302 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13302) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13317 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13317)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13339 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13339)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13354 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13354)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
-Case conversion may be inaccurate. Consider using '#align strict_anti.inv StrictAnti.invₓ'. -/
 @[to_additive]
 theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := fun x y hxy =>
   inv_lt_inv_iff.2 (hf hxy)
 #align strict_anti.inv StrictAnti.inv
 #align strict_anti.neg StrictAnti.neg
 
-/- warning: strict_mono_on.inv -> StrictMonoOn.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13421 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13421) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13436 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13436)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13458 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13458)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13473 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13473)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
-Case conversion may be inaccurate. Consider using '#align strict_mono_on.inv StrictMonoOn.invₓ'. -/
 @[to_additive]
 theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_lt_inv_iff.2 (hf hx hy hxy)
 #align strict_mono_on.inv StrictMonoOn.inv
 #align strict_mono_on.neg StrictMonoOn.neg
 
-/- warning: strict_anti_on.inv -> StrictAntiOn.inv is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13548 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13548) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13563 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13563)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13585 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13585)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13600 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13600)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
-Case conversion may be inaccurate. Consider using '#align strict_anti_on.inv StrictAntiOn.invₓ'. -/
 @[to_additive]
 theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s :=
   fun x hx y hy hxy => inv_lt_inv_iff.2 (hf hx hy hxy)

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -128,10 +128,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align left.inv_le_one_iff Left.inv_le_one_iffₓ'. -/
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.neg_nonpos_iff "Uses `left` co(ntra)variant."]
-theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a :=
-  by
-  rw [← mul_le_mul_iff_left a]
-  simp
+theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by rw [← mul_le_mul_iff_left a]; simp
 #align left.inv_le_one_iff Left.inv_le_one_iff
 #align left.neg_nonpos_iff Left.neg_nonpos_iff
 
@@ -143,10 +140,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align left.one_le_inv_iff Left.one_le_inv_iffₓ'. -/
 /-- Uses `left` co(ntra)variant. -/
 @[simp, to_additive Left.nonneg_neg_iff "Uses `left` co(ntra)variant."]
-theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 :=
-  by
-  rw [← mul_le_mul_iff_left a]
-  simp
+theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by rw [← mul_le_mul_iff_left a]; simp
 #align left.one_le_inv_iff Left.one_le_inv_iff
 #align left.nonneg_neg_iff Left.nonneg_neg_iff
 
@@ -157,10 +151,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.645 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.647) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.660 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.662)] {a : α} {b : α} {c : α}, Iff (LE.le.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c)) (LE.le.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
 Case conversion may be inaccurate. Consider using '#align le_inv_mul_iff_mul_le le_inv_mul_iff_mul_leₓ'. -/
 @[simp, to_additive]
-theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c :=
-  by
-  rw [← mul_le_mul_iff_left a]
-  simp
+theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c := by rw [← mul_le_mul_iff_left a]; simp
 #align le_inv_mul_iff_mul_le le_inv_mul_iff_mul_le
 #align le_neg_add_iff_add_le le_neg_add_iff_add_le
 
@@ -263,10 +254,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1482 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1484) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1497 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.1499)] {a : α} {b : α} {c : α}, Iff (LT.lt.{u1} α _inst_2 b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) c)) (LT.lt.{u1} α _inst_2 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) a b) c)
 Case conversion may be inaccurate. Consider using '#align lt_inv_mul_iff_mul_lt lt_inv_mul_iff_mul_ltₓ'. -/
 @[simp, to_additive]
-theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c :=
-  by
-  rw [← mul_lt_mul_iff_left a]
-  simp
+theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c := by rw [← mul_lt_mul_iff_left a]; simp
 #align lt_inv_mul_iff_mul_lt lt_inv_mul_iff_mul_lt
 #align lt_neg_add_iff_add_lt lt_neg_add_iff_add_lt
 
@@ -344,10 +332,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align right.inv_le_one_iff Right.inv_le_one_iffₓ'. -/
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.neg_nonpos_iff "Uses `right` co(ntra)variant."]
-theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a :=
-  by
-  rw [← mul_le_mul_iff_right a]
-  simp
+theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by rw [← mul_le_mul_iff_right a]; simp
 #align right.inv_le_one_iff Right.inv_le_one_iff
 #align right.neg_nonpos_iff Right.neg_nonpos_iff
 
@@ -359,10 +344,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align right.one_le_inv_iff Right.one_le_inv_iffₓ'. -/
 /-- Uses `right` co(ntra)variant. -/
 @[simp, to_additive Right.nonneg_neg_iff "Uses `right` co(ntra)variant."]
-theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 :=
-  by
-  rw [← mul_le_mul_iff_right a]
-  simp
+theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by rw [← mul_le_mul_iff_right a]; simp
 #align right.one_le_inv_iff Right.one_le_inv_iff
 #align right.nonneg_neg_iff Right.nonneg_neg_iff
 
@@ -580,10 +562,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LE.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4084 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4086 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4084 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4086) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4099 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4101 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4099 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4101)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4121 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4123 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4121 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4123)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4136 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4138 : α) => LE.le.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4136 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4138)] {a : α} {b : α}, Iff (LE.le.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LE.le.{u1} α _inst_2 b a)
 Case conversion may be inaccurate. Consider using '#align inv_le_inv_iff inv_le_inv_iffₓ'. -/
 @[simp, to_additive]
-theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a :=
-  by
-  rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]
-  simp
+theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
+  rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]; simp
 #align inv_le_inv_iff inv_le_inv_iff
 #align neg_le_neg_iff neg_le_neg_iff
 
@@ -654,10 +634,8 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LT.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4674 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4676 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4674 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4676) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4689 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4691 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4689 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4691)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4711 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4713 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4711 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4713)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4726 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4728 : α) => LT.lt.{u1} α _inst_2 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4726 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.4728)] {a : α} {b : α}, Iff (LT.lt.{u1} α _inst_2 (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) b)) (LT.lt.{u1} α _inst_2 b a)
 Case conversion may be inaccurate. Consider using '#align inv_lt_inv_iff inv_lt_inv_iffₓ'. -/
 @[simp, to_additive]
-theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a :=
-  by
-  rw [← mul_lt_mul_iff_left a, ← mul_lt_mul_iff_right b]
-  simp
+theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a := by
+  rw [← mul_lt_mul_iff_left a, ← mul_lt_mul_iff_right b]; simp
 #align inv_lt_inv_iff inv_lt_inv_iff
 #align neg_lt_neg_iff neg_lt_neg_iff
 
@@ -2144,11 +2122,7 @@ def mkOfPositiveCone {α : Type _} [AddCommGroup α] (C : TotalPositiveCone α)
   {
     OrderedAddCommGroup.mkOfPositiveCone
       C.toPositiveCone with
-    le_total := fun a b => by
-      convert C.nonneg_total (b - a)
-      change C.nonneg _ = _
-      congr
-      simp
+    le_total := fun a b => by convert C.nonneg_total (b - a); change C.nonneg _ = _; congr ; simp
     decidableLe := fun a b => C.nonnegDecidable _ }
 #align linear_ordered_add_comm_group.mk_of_positive_cone LinearOrderedAddCommGroup.mkOfPositiveCone
 -/

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -2234,7 +2234,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Monotone.{u2, u1} β α _inst_5 _inst_2 f) -> (Antitone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12589 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12589 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12604 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12604 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12626 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12626 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12641 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12641 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12593 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12593) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12608 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12608)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12630 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12630)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12645 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12645)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align monotone.inv Monotone.invₓ'. -/
 @[to_additive]
 theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2246,7 +2246,7 @@ theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Antitone.{u2, u1} β α _inst_5 _inst_2 f) -> (Monotone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12708 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12708 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12723 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12723 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12745 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12745 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12760 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12760 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12712 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12712) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12727 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12727)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12749 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12749)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12764 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12764)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align antitone.inv Antitone.invₓ'. -/
 @[to_additive]
 theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2258,7 +2258,7 @@ theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12827 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12827 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12842 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12842 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12864 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12864 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12879 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12879 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12831 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12831) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12846 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12846)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12868 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12868)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12883 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12883)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align monotone_on.inv MonotoneOn.invₓ'. -/
 @[to_additive]
 theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s :=
@@ -2270,7 +2270,7 @@ theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12954 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12954 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12969 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12969 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12991 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12991 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13006 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13006 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12958 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12958) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12973 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12973)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12995 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12995)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13010 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13010)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align antitone_on.inv AntitoneOn.invₓ'. -/
 @[to_additive]
 theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s :=
@@ -2289,7 +2289,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictMono.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictAnti.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13179 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13179 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13194 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13194 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13216 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13216 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13231 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13231 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13183 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13183) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13198 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13198)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13220 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13220)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13235 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13235)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_mono.inv StrictMono.invₓ'. -/
 @[to_additive]
 theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2301,7 +2301,7 @@ theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictAnti.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictMono.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13298 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13298 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13313 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13313 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13335 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13335 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13350 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13350 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13302 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13302) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13317 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13317)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13339 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13339)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13354 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13354)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_anti.inv StrictAnti.invₓ'. -/
 @[to_additive]
 theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2313,7 +2313,7 @@ theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13417 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13417 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13432 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13432 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13454 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13454 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13469 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13469 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13421 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13421) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13436 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13436)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13458 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13458)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13473 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13473)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_mono_on.inv StrictMonoOn.invₓ'. -/
 @[to_additive]
 theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s :=
@@ -2325,7 +2325,7 @@ theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13544 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13544 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13559 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13559 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13581 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13581 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13596 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13596 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13548 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13548) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13563 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13563)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13585 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13585)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13600 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13600)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_anti_on.inv StrictAntiOn.invₓ'. -/
 @[to_additive]
 theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s :=

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -56,7 +56,7 @@ attribute [to_additive] OrderedCommGroup
 
 /- warning: ordered_comm_group.to_covariant_class_left_le -> OrderedCommGroup.to_covariantClass_left_le is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
+  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.96 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.98 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.96 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.98) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.111 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.113 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.111 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.113)
 Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_covariant_class_left_le OrderedCommGroup.to_covariantClass_left_leₓ'. -/
@@ -82,7 +82,7 @@ example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (·
 
 /- warning: ordered_comm_group.to_contravariant_class_left_le -> OrderedCommGroup.to_contravariantClass_left_le is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
+  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.244 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.246 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.244 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.246) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.259 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.261 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.259 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.261)
 Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_leₓ'. -/
@@ -98,7 +98,7 @@ theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCom
 
 /- warning: ordered_comm_group.to_contravariant_class_right_le -> OrderedCommGroup.to_contravariantClass_right_le is a dubious translation:
 lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
+  forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))))
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.315 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.317 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.315 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.317)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.330 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.332 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.330 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.332)
 Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_leₓ'. -/
@@ -750,7 +750,7 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)] {a : α}
 
 /- warning: left.inv_le_self -> Left.inv_le_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
 Case conversion may be inaccurate. Consider using '#align left.inv_le_self Left.inv_le_selfₓ'. -/
@@ -762,7 +762,7 @@ theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
 
 /- warning: neg_le_self -> neg_le_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) a) a)
+  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) a) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5394 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5396) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5409 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5411)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) a) a)
 Case conversion may be inaccurate. Consider using '#align neg_le_self neg_le_selfₓ'. -/
@@ -771,7 +771,7 @@ alias Left.neg_le_self ← neg_le_self
 
 /- warning: left.self_le_inv -> Left.self_le_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5463 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5465 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5463 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5465) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5478 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5480 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5478 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5480)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align left.self_le_inv Left.self_le_invₓ'. -/
@@ -789,7 +789,7 @@ variable [CovariantClass α α (· * ·) (· < ·)] {a : α}
 
 /- warning: left.inv_lt_self -> Left.inv_lt_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
 Case conversion may be inaccurate. Consider using '#align left.inv_lt_self Left.inv_lt_selfₓ'. -/
@@ -801,7 +801,7 @@ theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
 
 /- warning: neg_lt_self -> neg_lt_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) a) a)
+  forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toHasAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (AddZeroClass.toHasZero.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (Neg.neg.{u1} α (SubNegMonoid.toHasNeg.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1)) a) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : AddGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579 : α) => HAdd.hAdd.{u1, u1, u1} α α α (instHAdd.{u1} α (AddZeroClass.toAdd.{u1} α (AddMonoid.toAddZeroClass.{u1} α (SubNegMonoid.toAddMonoid.{u1} α (AddGroup.toSubNegMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5577 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5579) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5592 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5594)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (NegZeroClass.toZero.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Neg.neg.{u1} α (NegZeroClass.toNeg.{u1} α (SubNegZeroMonoid.toNegZeroClass.{u1} α (SubtractionMonoid.toSubNegZeroMonoid.{u1} α (AddGroup.toSubtractionMonoid.{u1} α _inst_1)))) a) a)
 Case conversion may be inaccurate. Consider using '#align neg_lt_self neg_lt_selfₓ'. -/
@@ -810,7 +810,7 @@ alias Left.neg_lt_self ← neg_lt_self
 
 /- warning: left.self_lt_inv -> Left.self_lt_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5646 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5648 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5646 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5648) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5661 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5663 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5661 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5663)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align left.self_lt_inv Left.self_lt_invₓ'. -/
@@ -828,7 +828,7 @@ variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a : α}
 
 /- warning: right.inv_le_self -> Right.inv_le_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5766 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5768 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5766 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5768)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5781 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5783 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5781 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5783)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
 Case conversion may be inaccurate. Consider using '#align right.inv_le_self Right.inv_le_selfₓ'. -/
@@ -840,7 +840,7 @@ theorem Right.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
 
 /- warning: right.self_le_inv -> Right.self_le_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5836 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5838 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5836 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5838)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5851 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5853 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5851 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5853)] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align right.self_le_inv Right.self_le_invₓ'. -/
@@ -858,7 +858,7 @@ variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a : α}
 
 /- warning: right.inv_lt_self -> Right.inv_lt_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5956 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5958 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5956 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5958)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5971 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5973 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5971 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.5973)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) a)
 Case conversion may be inaccurate. Consider using '#align right.inv_lt_self Right.inv_lt_selfₓ'. -/
@@ -870,7 +870,7 @@ theorem Right.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
 
 /- warning: right.self_lt_inv -> Right.self_lt_inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6026 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6028 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6026 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6028)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6041 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6043 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6041 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.6043)] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a))
 Case conversion may be inaccurate. Consider using '#align right.self_lt_inv Right.self_lt_invₓ'. -/
@@ -1508,7 +1508,7 @@ variable [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : 
 
 /- warning: div_le_div'' -> div_le_div'' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] {a : α} {b : α} {c : α} {d : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
+  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] {a : α} {b : α} {c : α} {d : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8678 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8680 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8678 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8680) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8693 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8695 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8693 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.8695)] {a : α} {b : α} {c : α} {d : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
 Case conversion may be inaccurate. Consider using '#align div_le_div'' div_le_div''ₓ'. -/
@@ -1845,7 +1845,7 @@ variable [Preorder α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
 /- warning: div_lt_div'' -> div_lt_div'' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] {a : α} {b : α} {c : α} {d : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
+  forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] {a : α} {b : α} {c : α} {d : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : CommGroup.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10468 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10470 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10468 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10470) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10483 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10485 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10483 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10485)] {a : α} {b : α} {c : α} {d : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) a d) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_1)))) b c))
 Case conversion may be inaccurate. Consider using '#align div_lt_div'' div_lt_div''ₓ'. -/
@@ -1867,7 +1867,7 @@ variable [Group α] [LinearOrder α]
 
 /- warning: cmp_div_one' -> cmp_div_one' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] (a : α) (b : α), Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_2 a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_2 a b) a b)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] (a : α) (b : α), Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_2 a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))))) (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_2 a b) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10592 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10594 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10592 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10594)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10607 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10609 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10607 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10609)] (a : α) (b : α), Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_2 a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1))))))) (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_2 a b) a b)
 Case conversion may be inaccurate. Consider using '#align cmp_div_one' cmp_div_one'ₓ'. -/
@@ -1885,7 +1885,7 @@ variable {a b c : α}
 
 /- warning: le_of_forall_one_lt_lt_mul -> le_of_forall_one_lt_lt_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α}, (forall (ε : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) ε) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α}, (forall (ε : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) ε) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10779 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10781 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10779 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10781) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10794 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10796 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10794 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10796)] {a : α} {b : α}, (forall (ε : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) ε) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a b)
 Case conversion may be inaccurate. Consider using '#align le_of_forall_one_lt_lt_mul le_of_forall_one_lt_lt_mulₓ'. -/
@@ -1897,7 +1897,7 @@ theorem le_of_forall_one_lt_lt_mul (h : ∀ ε : α, 1 < ε → a < b * ε) : a
 
 /- warning: le_iff_forall_one_lt_lt_mul -> le_iff_forall_one_lt_lt_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b) (forall (ε : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) ε) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε)))
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b) (forall (ε : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) ε) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10868 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10870 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10868 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10870) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10883 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10885 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10883 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10885)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a b) (forall (ε : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))))) ε) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) b ε)))
 Case conversion may be inaccurate. Consider using '#align le_iff_forall_one_lt_lt_mul le_iff_forall_one_lt_lt_mulₓ'. -/
@@ -1909,7 +1909,7 @@ theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε
 
 /- warning: div_le_inv_mul_iff -> div_le_inv_mul_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α} [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b)
+  forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))] {a : α} {b : α} [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) a) b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Group.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10949 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10951 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10949 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10951) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10964 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10966 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10964 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10966)] {a : α} {b : α} [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10989 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10991 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10989 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.10991)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11004 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11006 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11004 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11006)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (Group.toDivisionMonoid.{u1} α _inst_1)))) a) b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a b)
 Case conversion may be inaccurate. Consider using '#align div_le_inv_mul_iff div_le_inv_mul_iffₓ'. -/
@@ -1927,7 +1927,7 @@ theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
 
 /- warning: div_le_div_flip -> div_le_div_flip is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_4 : CommGroup.{u1} α] [_inst_5 : LinearOrder.{u1} α] [_inst_6 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))))] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) b a)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))) a b)
+  forall {α : Type.{u1}} [_inst_4 : CommGroup.{u1} α] [_inst_5 : LinearOrder.{u1} α] [_inst_6 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))))] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toHasDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) b a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_5))))) a b)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_4 : CommGroup.{u1} α] [_inst_5 : LinearOrder.{u1} α] [_inst_6 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11152 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11154 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11152 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11154) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11167 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11169 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_5)))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11167 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.11169)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_5)))))) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) a b) (HDiv.hDiv.{u1, u1, u1} α α α (instHDiv.{u1} α (DivInvMonoid.toDiv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α _inst_4)))) b a)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_5)))))) a b)
 Case conversion may be inaccurate. Consider using '#align div_le_div_flip div_le_div_flipₓ'. -/
@@ -1986,7 +1986,7 @@ variable [LinearOrderedCommGroup α] {a b c : α}
 
 /- warning: linear_ordered_comm_group.mul_lt_mul_left' -> LinearOrderedCommGroup.mul_lt_mul_left' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] (a : α) (b : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) a b) -> (forall (c : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c b))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] (a : α) (b : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) a b) -> (forall (c : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] (a : α) (b : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) a b) -> (forall (c : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))) c b))
 Case conversion may be inaccurate. Consider using '#align linear_ordered_comm_group.mul_lt_mul_left' LinearOrderedCommGroup.mul_lt_mul_left'ₓ'. -/
@@ -2017,7 +2017,7 @@ theorem eq_one_of_inv_eq' (h : a⁻¹ = a) : a = 1 :=
 
 /- warning: exists_one_lt' -> exists_one_lt' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], Exists.{succ u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))))) a)
+  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], Exists.{succ u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))))))))) a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], Exists.{succ u1} α (fun (a : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1)))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))))))) a)
 Case conversion may be inaccurate. Consider using '#align exists_one_lt' exists_one_lt'ₓ'. -/
@@ -2031,7 +2031,12 @@ theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a :=
 #align exists_one_lt' exists_one_lt'
 #align exists_zero_lt exists_zero_lt
 
-#print LinearOrderedCommGroup.to_noMaxOrder /-
+/- warning: linear_ordered_comm_group.to_no_max_order -> LinearOrderedCommGroup.to_noMaxOrder is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
+Case conversion may be inaccurate. Consider using '#align linear_ordered_comm_group.to_no_max_order LinearOrderedCommGroup.to_noMaxOrderₓ'. -/
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LinearOrderedCommGroup.to_noMaxOrder [Nontrivial α] : NoMaxOrder α :=
@@ -2040,9 +2045,13 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMaxOrder [Nontrivial α]
     exact fun a => ⟨a * y, lt_mul_of_one_lt_right' a hy⟩⟩
 #align linear_ordered_comm_group.to_no_max_order LinearOrderedCommGroup.to_noMaxOrder
 #align linear_ordered_add_comm_group.to_no_max_order LinearOrderedAddCommGroup.to_noMaxOrder
--/
 
-#print LinearOrderedCommGroup.to_noMinOrder /-
+/- warning: linear_ordered_comm_group.to_no_min_order -> LinearOrderedCommGroup.to_noMinOrder is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrderedCommGroup.{u1} α] [_inst_2 : Nontrivial.{u1} α], NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α (LinearOrderedCommGroup.toOrderedCommGroup.{u1} α _inst_1))))
+Case conversion may be inaccurate. Consider using '#align linear_ordered_comm_group.to_no_min_order LinearOrderedCommGroup.to_noMinOrderₓ'. -/
 -- see Note [lower instance priority]
 @[to_additive]
 instance (priority := 100) LinearOrderedCommGroup.to_noMinOrder [Nontrivial α] : NoMinOrder α :=
@@ -2051,7 +2060,6 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMinOrder [Nontrivial α]
     exact fun a => ⟨a / y, (div_lt_self_iff a).mpr hy⟩⟩
 #align linear_ordered_comm_group.to_no_min_order LinearOrderedCommGroup.to_noMinOrder
 #align linear_ordered_add_comm_group.to_no_min_order LinearOrderedAddCommGroup.to_noMinOrder
--/
 
 #print LinearOrderedCommGroup.toLinearOrderedCancelCommMonoid /-
 -- See note [lower instance priority]
@@ -2155,7 +2163,7 @@ variable [OrderedCommGroup α] {a b : α}
 
 /- warning: inv_le_inv' -> inv_le_inv' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
+  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) b) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a))
 Case conversion may be inaccurate. Consider using '#align inv_le_inv' inv_le_inv'ₓ'. -/
@@ -2167,7 +2175,7 @@ theorem inv_le_inv' : a ≤ b → b⁻¹ ≤ a⁻¹ :=
 
 /- warning: inv_lt_inv' -> inv_lt_inv' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
+  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) b) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) b) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a))
 Case conversion may be inaccurate. Consider using '#align inv_lt_inv' inv_lt_inv'ₓ'. -/
@@ -2179,7 +2187,7 @@ theorem inv_lt_inv' : a < b → b⁻¹ < a⁻¹ :=
 
 /- warning: inv_lt_one_of_one_lt -> inv_lt_one_of_one_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))))
+  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))))
 Case conversion may be inaccurate. Consider using '#align inv_lt_one_of_one_lt inv_lt_one_of_one_ltₓ'. -/
@@ -2192,7 +2200,7 @@ theorem inv_lt_one_of_one_lt : 1 < a → a⁻¹ < 1 :=
 
 /- warning: inv_le_one_of_one_le -> inv_le_one_of_one_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))))
+  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))))
 Case conversion may be inaccurate. Consider using '#align inv_le_one_of_one_le inv_le_one_of_one_leₓ'. -/
@@ -2205,7 +2213,7 @@ theorem inv_le_one_of_one_le : 1 ≤ a → a⁻¹ ≤ 1 :=
 
 /- warning: one_le_inv_of_le_one -> one_le_inv_of_le_one is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
+  forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) (Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))) a))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : OrderedCommGroup.{u1} α] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (InvOneClass.toOne.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))))) (Inv.inv.{u1} α (InvOneClass.toInv.{u1} α (DivInvOneMonoid.toInvOneClass.{u1} α (DivisionMonoid.toDivInvOneMonoid.{u1} α (DivisionCommMonoid.toDivisionMonoid.{u1} α (CommGroup.toDivisionCommMonoid.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1)))))) a))
 Case conversion may be inaccurate. Consider using '#align one_le_inv_of_le_one one_le_inv_of_le_oneₓ'. -/
@@ -2224,7 +2232,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 
 /- warning: monotone.inv -> Monotone.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Monotone.{u2, u1} β α _inst_5 _inst_2 f) -> (Antitone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Monotone.{u2, u1} β α _inst_5 _inst_2 f) -> (Antitone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12589 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12589 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12604 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12604 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12626 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12626 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12641 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12641 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align monotone.inv Monotone.invₓ'. -/
@@ -2236,7 +2244,7 @@ theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y
 
 /- warning: antitone.inv -> Antitone.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Antitone.{u2, u1} β α _inst_5 _inst_2 f) -> (Monotone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Antitone.{u2, u1} β α _inst_5 _inst_2 f) -> (Monotone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12708 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12708 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12723 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12723 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12745 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12745 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12760 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12760 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align antitone.inv Antitone.invₓ'. -/
@@ -2248,7 +2256,7 @@ theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y
 
 /- warning: monotone_on.inv -> MonotoneOn.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12827 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12827 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12842 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12842 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12864 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12864 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12879 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12879 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align monotone_on.inv MonotoneOn.invₓ'. -/
@@ -2260,7 +2268,7 @@ theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹)
 
 /- warning: antitone_on.inv -> AntitoneOn.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12954 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12954 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12969 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12969 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12991 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12991 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13006 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13006 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align antitone_on.inv AntitoneOn.invₓ'. -/
@@ -2279,7 +2287,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 
 /- warning: strict_mono.inv -> StrictMono.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictMono.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictAnti.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictMono.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictAnti.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13179 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13179 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13194 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13194 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13216 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13216 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13231 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13231 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_mono.inv StrictMono.invₓ'. -/
@@ -2291,7 +2299,7 @@ theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := f
 
 /- warning: strict_anti.inv -> StrictAnti.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictAnti.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictMono.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictAnti.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictMono.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13298 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13298 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13313 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13313 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13335 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13335 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13350 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13350 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_anti.inv StrictAnti.invₓ'. -/
@@ -2303,7 +2311,7 @@ theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := f
 
 /- warning: strict_mono_on.inv -> StrictMonoOn.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13417 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13417 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13432 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13432 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13454 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13454 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13469 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13469 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_mono_on.inv StrictMonoOn.invₓ'. -/
@@ -2315,7 +2323,7 @@ theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)
 
 /- warning: strict_anti_on.inv -> StrictAntiOn.inv is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13544 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13544 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13559 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13559 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13581 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13581 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13596 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13596 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_anti_on.inv StrictAntiOn.invₓ'. -/

bump to nightly-2023-05-13-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/403190b5419b3f03f1a2893ad9352ca7f7d8bff6

d312d6d5

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 
 ! This file was ported from Lean 3 source module algebra.order.group.defs
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit b599f4e4e5cf1fbcb4194503671d3d9e569c1fce
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -86,11 +86,13 @@ lean 3 declaration is
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.244 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.246 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.244 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.246) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.259 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.261 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.259 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.261)
 Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_leₓ'. -/
+-- Backporting note: this instance is not used,
+-- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
-instance OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCommGroup α] :
-    ContravariantClass α α (· * ·) (· ≤ ·)
-    where elim a b c bc := by simpa using mul_le_mul_left' bc a⁻¹
+theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCommGroup α] :
+    ContravariantClass α α (· * ·) (· ≤ ·) :=
+  { elim := fun a b c bc => by simpa using mul_le_mul_left' bc a⁻¹ }
 #align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
 #align ordered_add_comm_group.to_contravariant_class_left_le OrderedAddCommGroup.to_contravariantClass_left_le
 
@@ -100,11 +102,13 @@ lean 3 declaration is
 but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : OrderedCommGroup.{u1} α], ContravariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.315 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.317 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α (CommGroup.toGroup.{u1} α (OrderedCommGroup.toCommGroup.{u1} α _inst_1))))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.315 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.317)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.330 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.332 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (OrderedCommGroup.toPartialOrder.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.330 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.332)
 Case conversion may be inaccurate. Consider using '#align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_leₓ'. -/
+-- Backporting note: this instance is not used,
+-- and causes timeouts when interacting with etaExperiment.
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
-instance OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedCommGroup α] :
-    ContravariantClass α α (swap (· * ·)) (· ≤ ·)
-    where elim a b c bc := by simpa using mul_le_mul_right' bc a⁻¹
+theorem OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedCommGroup α] :
+    ContravariantClass α α (swap (· * ·)) (· ≤ ·) :=
+  { elim := fun a b c bc => by simpa using mul_le_mul_right' bc a⁻¹ }
 #align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_le
 #align ordered_add_comm_group.to_contravariant_class_right_le OrderedAddCommGroup.to_contravariantClass_right_le

bump to nightly-2023-03-28-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/728baa2f54e6062c5879a3e397ac6bac323e506f

869495ce

Diff

@@ -2222,7 +2222,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Monotone.{u2, u1} β α _inst_5 _inst_2 f) -> (Antitone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12542 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12544 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12542 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12544) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12557 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12559 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12557 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12559)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12579 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12581 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12579 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12581)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12594 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12596 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12594 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12596)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12589 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12589 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12591) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12604 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12604 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12606)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12626 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12626 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12628)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12641 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12641 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12643)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align monotone.inv Monotone.invₓ'. -/
 @[to_additive]
 theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2234,7 +2234,7 @@ theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Antitone.{u2, u1} β α _inst_5 _inst_2 f) -> (Monotone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12661 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12663 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12661 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12663) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12676 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12678 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12676 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12678)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12698 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12700 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12698 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12700)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12713 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12715 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12713 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12715)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12708 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12708 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12710) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12723 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12723 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12725)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12745 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12745 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12747)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12760 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12760 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12762)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align antitone.inv Antitone.invₓ'. -/
 @[to_additive]
 theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2246,7 +2246,7 @@ theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12780 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12782 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12780 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12782) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12795 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12797 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12795 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12797)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12817 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12819 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12817 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12819)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12832 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12834 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12832 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12834)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12827 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12827 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12829) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12842 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12842 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12844)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12864 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12864 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12866)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12879 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12879 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12881)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align monotone_on.inv MonotoneOn.invₓ'. -/
 @[to_additive]
 theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s :=
@@ -2258,7 +2258,7 @@ theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12907 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12909 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12907 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12909) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12922 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12924 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12922 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12924)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12944 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12946 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12944 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12946)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12959 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12961 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12959 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12961)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12954 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12954 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12956) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12969 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12969 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12971)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12991 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12991 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12993)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13006 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13006 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13008)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align antitone_on.inv AntitoneOn.invₓ'. -/
 @[to_additive]
 theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s :=
@@ -2277,7 +2277,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictMono.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictAnti.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13132 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13134 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13132 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13134) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13147 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13149 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13147 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13149)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13169 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13171 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13169 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13171)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13184 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13186 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13184 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13186)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13179 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13179 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13181) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13194 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13194 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13196)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13216 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13216 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13218)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13231 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13231 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13233)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_mono.inv StrictMono.invₓ'. -/
 @[to_additive]
 theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2289,7 +2289,7 @@ theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictAnti.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictMono.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13251 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13253 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13251 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13253) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13266 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13268 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13266 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13268)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13288 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13290 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13288 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13290)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13303 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13305 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13303 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13305)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13298 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13298 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13300) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13313 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13313 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13315)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13335 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13335 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13337)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13350 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13350 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13352)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_anti.inv StrictAnti.invₓ'. -/
 @[to_additive]
 theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2301,7 +2301,7 @@ theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13370 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13372 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13370 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13372) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13385 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13387 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13385 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13387)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13407 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13409 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13407 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13409)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13422 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13424 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13422 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13424)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13417 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13417 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13419) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13432 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13432 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13434)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13454 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13454 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13456)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13469 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13469 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13471)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_mono_on.inv StrictMonoOn.invₓ'. -/
 @[to_additive]
 theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s :=
@@ -2313,7 +2313,7 @@ theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13497 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13499 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13497 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13499) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13512 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13514 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13512 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13514)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13534 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13536 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13534 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13536)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13549 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13551 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13549 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13551)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13544 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13544 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13546) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13559 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13559 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13561)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13581 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13581 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13583)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13596 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13596 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13598)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_anti_on.inv StrictAntiOn.invₓ'. -/
 @[to_additive]
 theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s :=

bump to nightly-2023-03-08-00

mathlib commit https://github.com/leanprover-community/mathlib/commit/3b267e70a936eebb21ab546f49a8df34dd300b25

101eaa63

Diff

@@ -2222,7 +2222,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Monotone.{u2, u1} β α _inst_5 _inst_2 f) -> (Antitone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12543 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12545 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12543 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12545) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12558 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12560 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12558 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12560)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12580 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12582 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12580 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12582)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12595 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12597 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12595 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12597)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12542 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12544 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12542 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12544) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12557 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12559 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12557 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12559)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12579 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12581 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12579 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12581)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12594 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12596 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12594 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12596)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Monotone.{u1, u2} β α _inst_5 _inst_2 f) -> (Antitone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align monotone.inv Monotone.invₓ'. -/
 @[to_additive]
 theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2234,7 +2234,7 @@ theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun x y
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (Antitone.{u2, u1} β α _inst_5 _inst_2 f) -> (Monotone.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12662 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12664 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12662 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12664) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12677 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12679 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12677 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12679)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12699 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12701 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12699 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12701)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12714 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12716 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12714 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12716)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12661 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12663 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12661 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12663) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12676 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12678 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12676 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12678)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12698 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12700 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12698 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12700)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12713 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12715 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12713 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12715)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (Antitone.{u1, u2} β α _inst_5 _inst_2 f) -> (Monotone.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align antitone.inv Antitone.invₓ'. -/
 @[to_additive]
 theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2246,7 +2246,7 @@ theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun x y
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12781 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12783 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12781 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12783) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12796 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12798 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12796 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12798)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12818 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12820 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12818 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12820)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12833 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12835 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12833 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12835)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12780 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12782 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12780 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12782) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12795 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12797 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12795 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12797)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12817 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12819 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12817 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12819)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12832 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12834 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12832 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12834)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align monotone_on.inv MonotoneOn.invₓ'. -/
 @[to_additive]
 theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s :=
@@ -2258,7 +2258,7 @@ theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (AntitoneOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12908 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12910 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12908 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12910) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12923 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12925 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12923 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12925)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12945 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12947 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12945 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12947)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12960 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12962 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12960 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12962)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12907 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12909 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12907 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12909) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12922 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12924 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12922 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12924)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12944 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12946 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12944 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12946)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12959 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12961 : α) => LE.le.{u2} α (Preorder.toLE.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12959 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.12961)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (AntitoneOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (MonotoneOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align antitone_on.inv AntitoneOn.invₓ'. -/
 @[to_additive]
 theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s :=
@@ -2277,7 +2277,7 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictMono.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictAnti.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13133 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13135 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13133 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13135) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13148 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13150 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13148 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13150)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13170 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13172 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13170 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13172)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13185 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13187 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13185 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13187)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13132 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13134 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13132 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13134) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13147 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13149 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13147 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13149)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13169 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13171 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13169 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13171)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13184 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13186 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13184 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13186)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictMono.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictAnti.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_mono.inv StrictMono.invₓ'. -/
 @[to_additive]
 theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2289,7 +2289,7 @@ theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α}, (StrictAnti.{u2, u1} β α _inst_5 _inst_2 f) -> (StrictMono.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13252 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13254 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13252 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13254) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13267 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13269 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13267 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13269)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13289 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13291 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13289 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13291)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13304 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13306 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13304 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13306)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13251 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13253 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13251 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13253) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13266 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13268 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13266 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13268)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13288 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13290 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13288 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13290)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13303 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13305 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13303 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13305)] [_inst_5 : Preorder.{u1} β] {f : β -> α}, (StrictAnti.{u1, u2} β α _inst_5 _inst_2 f) -> (StrictMono.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)))
 Case conversion may be inaccurate. Consider using '#align strict_anti.inv StrictAnti.invₓ'. -/
 @[to_additive]
 theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := fun x y hxy =>
@@ -2301,7 +2301,7 @@ theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := f
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13371 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13373 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13371 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13373) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13386 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13388 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13386 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13388)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13408 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13410 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13408 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13410)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13423 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13425 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13423 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13425)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13370 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13372 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13370 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13372) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13385 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13387 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13385 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13387)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13407 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13409 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13407 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13409)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13422 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13424 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13422 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13424)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_mono_on.inv StrictMonoOn.invₓ'. -/
 @[to_additive]
 theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s :=
@@ -2313,7 +2313,7 @@ theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Group.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α (Monoid.toMulOneClass.{u1} α (DivInvMonoid.toMonoid.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1))))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2))] [_inst_5 : Preorder.{u2} β] {f : β -> α} {s : Set.{u2} β}, (StrictAntiOn.{u2, u1} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u2, u1} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u1} α (DivInvMonoid.toHasInv.{u1} α (Group.toDivInvMonoid.{u1} α _inst_1)) (f x)) s)
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13498 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13500 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13498 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13500) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13513 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13515 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13513 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13515)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13535 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13537 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13535 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13537)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13550 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13552 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13550 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13552)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Group.{u2} α] [_inst_2 : Preorder.{u2} α] [_inst_3 : CovariantClass.{u2, u2} α α (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13497 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13499 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13497 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13499) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13512 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13514 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13512 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13514)] [_inst_4 : CovariantClass.{u2, u2} α α (Function.swap.{succ u2, succ u2, succ u2} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13534 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13536 : α) => HMul.hMul.{u2, u2, u2} α α α (instHMul.{u2} α (MulOneClass.toMul.{u2} α (Monoid.toMulOneClass.{u2} α (DivInvMonoid.toMonoid.{u2} α (Group.toDivInvMonoid.{u2} α _inst_1))))) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13534 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13536)) (fun (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13549 : α) (x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13551 : α) => LT.lt.{u2} α (Preorder.toLT.{u2} α _inst_2) x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13549 x._@.Mathlib.Algebra.Order.Group.Defs._hyg.13551)] [_inst_5 : Preorder.{u1} β] {f : β -> α} {s : Set.{u1} β}, (StrictAntiOn.{u1, u2} β α _inst_5 _inst_2 f s) -> (StrictMonoOn.{u1, u2} β α _inst_5 _inst_2 (fun (x : β) => Inv.inv.{u2} α (InvOneClass.toInv.{u2} α (DivInvOneMonoid.toInvOneClass.{u2} α (DivisionMonoid.toDivInvOneMonoid.{u2} α (Group.toDivisionMonoid.{u2} α _inst_1)))) (f x)) s)
 Case conversion may be inaccurate. Consider using '#align strict_anti_on.inv StrictAntiOn.invₓ'. -/
 @[to_additive]
 theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s :=

bump to nightly-2023-03-01-20

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

20cadee0

Diff

@@ -2064,7 +2064,7 @@ end LinearOrderedCommGroup
 namespace AddCommGroup
 
 #print AddCommGroup.PositiveCone /-
-/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:72:18: unsupported non-interactive tactic order_laws_tac -/
+/- ./././Mathport/Syntax/Translate/Tactic/Builtin.lean:69:18: unsupported non-interactive tactic order_laws_tac -/
 /-- A collection of elements in an `add_comm_group` designated as "non-negative".
 This is useful for constructing an `ordered_add_commm_group`
 by choosing a positive cone in an exisiting `add_comm_group`. -/

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

chore: classify porting notes referring to missing linters (#12098)

Reference the newly created issues #12094 and #12096, as well as the pre-existing #5171. Change all references to #10927 to #5171. Some of these changes were not labelled as "porting note"; change this for good measure.

c5b5490c

Diff

@@ -24,7 +24,7 @@ namespace AddCommGroup
 /-- A collection of elements in an `AddCommGroup` designated as "non-negative".
 This is useful for constructing an `OrderedAddCommGroup`
 by choosing a positive cone in an existing `AddCommGroup`. -/
--- Porting note: @[nolint has_nonempty_instance]
+-- Porting note(#5171): @[nolint has_nonempty_instance]
 structure PositiveCone (α : Type*) [AddCommGroup α] where
   /-- The characteristic predicate of a positive cone. `nonneg a` means that `0 ≤ a` according to
   the cone. -/
@@ -40,7 +40,7 @@ structure PositiveCone (α : Type*) [AddCommGroup α] where
 
 /-- A positive cone in an `AddCommGroup` induces a linear order if
 for every `a`, either `a` or `-a` is non-negative. -/
--- Porting note: @[nolint has_nonempty_instance]
+-- Porting note(#5171): @[nolint has_nonempty_instance]
 structure TotalPositiveCone (α : Type*) [AddCommGroup α] extends PositiveCone α where
   /-- For any `a` the proposition `nonneg a` is decidable -/
   nonnegDecidable : DecidablePred nonneg

chore: Rename mul-div cancellation lemmas (#11530)

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

4ea4a86a

Diff

@@ -1036,7 +1036,7 @@ variable [Group α] [LinearOrder α]
 
 @[to_additive (attr := simp) cmp_sub_zero]
 theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
-    cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel']
+    cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel]
 #align cmp_div_one' cmp_div_one'
 #align cmp_sub_zero cmp_sub_zero

chore(*): remove empty lines between variable statements (#11418)

Empty lines were removed by executing the following Python script twice

import os
import re


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

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

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

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

75c86f04

Diff

@@ -770,7 +770,6 @@ end Right
 section Left
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
-
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
 @[to_additive]

chore(Algebra/Order/Group): move PositiveCones to a new file (#10868)

Nothing else in the library (but a similar file about rings) depend on these constructors.

61dc2d08

Diff

@@ -1188,78 +1188,6 @@ theorem lt_inv_self_iff : a < a⁻¹ ↔ a < 1 := by simp [← not_iff_not]
 
 end LinearOrderedCommGroup
 
-namespace AddCommGroup
-
-/-- A collection of elements in an `AddCommGroup` designated as "non-negative".
-This is useful for constructing an `OrderedAddCommGroup`
-by choosing a positive cone in an existing `AddCommGroup`. -/
--- Porting note: @[nolint has_nonempty_instance]
-structure PositiveCone (α : Type*) [AddCommGroup α] where
-  /-- The characteristic predicate of a positive cone. `nonneg a` means that `0 ≤ a` according to
-  the cone. -/
-  nonneg : α → Prop
-  /-- The characteristic predicate of a positive cone. `pos a` means that `0 < a` according to
-  the cone. -/
-  pos : α → Prop := fun a => nonneg a ∧ ¬nonneg (-a)
-  pos_iff : ∀ a, pos a ↔ nonneg a ∧ ¬nonneg (-a) := by intros; rfl
-  zero_nonneg : nonneg 0
-  add_nonneg : ∀ {a b}, nonneg a → nonneg b → nonneg (a + b)
-  nonneg_antisymm : ∀ {a}, nonneg a → nonneg (-a) → a = 0
-#align add_comm_group.positive_cone AddCommGroup.PositiveCone
-
-/-- A positive cone in an `AddCommGroup` induces a linear order if
-for every `a`, either `a` or `-a` is non-negative. -/
--- Porting note: @[nolint has_nonempty_instance]
-structure TotalPositiveCone (α : Type*) [AddCommGroup α] extends PositiveCone α where
-  /-- For any `a` the proposition `nonneg a` is decidable -/
-  nonnegDecidable : DecidablePred nonneg
-  /-- Either `a` or `-a` is `nonneg` -/
-  nonneg_total : ∀ a : α, nonneg a ∨ nonneg (-a)
-#align add_comm_group.total_positive_cone AddCommGroup.TotalPositiveCone
-
-/-- Forget that a `TotalPositiveCone` is total. -/
-add_decl_doc TotalPositiveCone.toPositiveCone
-#align add_comm_group.total_positive_cone.to_positive_cone AddCommGroup.TotalPositiveCone.toPositiveCone
-
-end AddCommGroup
-
-namespace OrderedAddCommGroup
-
-open AddCommGroup
-
-/-- Construct an `OrderedAddCommGroup` by
-designating a positive cone in an existing `AddCommGroup`. -/
-def mkOfPositiveCone {α : Type*} [AddCommGroup α] (C : PositiveCone α) : OrderedAddCommGroup α :=
-  { ‹AddCommGroup α› with
-    le := fun a b => C.nonneg (b - a),
-    lt := fun a b => C.pos (b - a),
-    lt_iff_le_not_le := fun a b => by simp [C.pos_iff],
-    le_refl := fun a => by simp [C.zero_nonneg],
-    le_trans := fun a b c nab nbc => by simpa [← sub_add_sub_cancel] using C.add_nonneg nbc nab,
-    le_antisymm := fun a b nab nba =>
-      eq_of_sub_eq_zero <| C.nonneg_antisymm nba (by rwa [neg_sub]),
-    add_le_add_left := fun a b nab c => by simpa using nab }
-#align ordered_add_comm_group.mk_of_positive_cone OrderedAddCommGroup.mkOfPositiveCone
-
-end OrderedAddCommGroup
-
-namespace LinearOrderedAddCommGroup
-
-open AddCommGroup
-
-/-- Construct a `LinearOrderedAddCommGroup` by
-designating a positive cone in an existing `AddCommGroup`
-such that for every `a`, either `a` or `-a` is non-negative. -/
-def mkOfPositiveCone {α : Type*} [AddCommGroup α] (C : TotalPositiveCone α) :
-    LinearOrderedAddCommGroup α :=
-  { OrderedAddCommGroup.mkOfPositiveCone C.toPositiveCone with
-    -- Porting note: was `C.nonneg_total (b - a)`
-    le_total := fun a b => by simpa [neg_sub] using C.nonneg_total (b - a)
-    decidableLE := fun a b => C.nonnegDecidable _ }
-#align linear_ordered_add_comm_group.mk_of_positive_cone LinearOrderedAddCommGroup.mkOfPositiveCone
-
-end LinearOrderedAddCommGroup
-
 section NormNumLemmas
 
 /- The following lemmas are stated so that the `norm_num` tactic can use them with the

chore(Algebra/Order/Group): move PositiveCones to a new file (#10868)

Nothing else in the library (but a similar file about rings) depend on these constructors.

61dc2d08

chore: classify simp can do this porting notes (#10619)

Classify by adding issue number (#10618) to porting notes claiming anything semantically equivalent to simp can prove this or simp can simplify this.

de765f60

Diff

@@ -250,7 +250,7 @@ theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a :=
 #align le_mul_inv_iff_mul_le le_mul_inv_iff_mul_le
 #align le_add_neg_iff_add_le le_add_neg_iff_add_le
 
--- Porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 @[to_additive]
 theorem mul_inv_le_one_iff_le : a * b⁻¹ ≤ 1 ↔ a ≤ b :=
   mul_inv_le_iff_le_mul.trans <| by rw [one_mul]
@@ -313,7 +313,7 @@ theorem lt_mul_inv_iff_mul_lt : c < a * b⁻¹ ↔ c * b < a :=
 #align lt_mul_inv_iff_mul_lt lt_mul_inv_iff_mul_lt
 #align lt_add_neg_iff_add_lt lt_add_neg_iff_add_lt
 
--- Porting note: `simp` can prove this
+-- Porting note (#10618): `simp` can prove this
 @[to_additive]
 theorem inv_mul_lt_one_iff_lt : a * b⁻¹ < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right, one_mul]

chore(Tactic/GCongr): move @[gcongr] tags around (#9393)

Add import Mathlib.Tactic.GCongr.Core to Algebra/Order/Ring/Lemmas.
Move most @[gcongr] tags next to the lemmas.

See Zulip thread

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

cd4edcb7

Diff

@@ -711,7 +711,7 @@ theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b := by
 #align div_le_div_iff_right div_le_div_iff_right
 #align sub_le_sub_iff_right sub_le_sub_iff_right
 
-@[to_additive sub_le_sub_right]
+@[to_additive (attr := gcongr) sub_le_sub_right]
 theorem div_le_div_right' (h : a ≤ b) (c : α) : a / c ≤ b / c :=
   (div_le_div_iff_right c).2 h
 #align div_le_div_right' div_le_div_right'
@@ -780,7 +780,7 @@ theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b := by
 #align div_le_div_iff_left div_le_div_iff_left
 #align sub_le_sub_iff_left sub_le_sub_iff_left
 
-@[to_additive sub_le_sub_left]
+@[to_additive (attr := gcongr) sub_le_sub_left]
 theorem div_le_div_left' (h : a ≤ b) (c : α) : c / b ≤ c / a :=
   (div_le_div_iff_left c).2 h
 #align div_le_div_left' div_le_div_left'
@@ -851,7 +851,7 @@ section Preorder
 
 variable [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
-@[to_additive sub_le_sub]
+@[to_additive (attr := gcongr) sub_le_sub]
 theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c := by
   rw [div_eq_mul_inv, div_eq_mul_inv, mul_comm b, mul_inv_le_inv_mul_iff, mul_comm]
   exact mul_le_mul' hab hcd
@@ -878,7 +878,7 @@ theorem div_lt_div_iff_right (c : α) : a / c < b / c ↔ a < b := by
 #align div_lt_div_iff_right div_lt_div_iff_right
 #align sub_lt_sub_iff_right sub_lt_sub_iff_right
 
-@[to_additive sub_lt_sub_right]
+@[to_additive (attr := gcongr) sub_lt_sub_right]
 theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c :=
   (div_lt_div_iff_right c).2 h
 #align div_lt_div_right' div_lt_div_right'
@@ -947,7 +947,7 @@ theorem inv_lt_div_iff_lt_mul : a⁻¹ < b / c ↔ c < a * b := by
 #align inv_lt_div_iff_lt_mul inv_lt_div_iff_lt_mul
 #align neg_lt_sub_iff_lt_add neg_lt_sub_iff_lt_add
 
-@[to_additive sub_lt_sub_left]
+@[to_additive (attr := gcongr) sub_lt_sub_left]
 theorem div_lt_div_left' (h : a < b) (c : α) : c / b < c / a :=
   (div_lt_div_iff_left c).2 h
 #align div_lt_div_left' div_lt_div_left'
@@ -1013,7 +1013,7 @@ section Preorder
 
 variable [Preorder α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 
-@[to_additive sub_lt_sub]
+@[to_additive (attr := gcongr) sub_lt_sub]
 theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c := by
   rw [div_eq_mul_inv, div_eq_mul_inv, mul_comm b, mul_inv_lt_inv_mul_iff, mul_comm]
   exact mul_lt_mul_of_lt_of_lt hab hcd
@@ -1266,14 +1266,14 @@ section NormNumLemmas
 expected signatures.  -/
 variable [OrderedCommGroup α] {a b : α}
 
-@[to_additive neg_le_neg]
+@[to_additive (attr := gcongr) neg_le_neg]
 theorem inv_le_inv' : a ≤ b → b⁻¹ ≤ a⁻¹ :=
   -- Porting note: explicit type annotation was not needed before.
   (@inv_le_inv_iff α ..).mpr
 #align inv_le_inv' inv_le_inv'
 #align neg_le_neg neg_le_neg
 
-@[to_additive neg_lt_neg]
+@[to_additive (attr := gcongr) neg_lt_neg]
 theorem inv_lt_inv' : a < b → b⁻¹ < a⁻¹ :=
   -- Porting note: explicit type annotation was not needed before.
   (@inv_lt_inv_iff α ..).mpr

doc: @[inherit_doc] on notations (#9942)

Make all the notations that unambiguously should inherit the docstring of their definition actually inherit it.

Also write a few docstrings by hand. I only wrote the ones I was competent to write and which I was sure of. Some docstrings come from mathlib3 as they were lost during the early port.

This PR is only intended as a first pass There are many more docstrings to add.

08f7e99d

Diff

@@ -1195,7 +1195,11 @@ This is useful for constructing an `OrderedAddCommGroup`
 by choosing a positive cone in an existing `AddCommGroup`. -/
 -- Porting note: @[nolint has_nonempty_instance]
 structure PositiveCone (α : Type*) [AddCommGroup α] where
+  /-- The characteristic predicate of a positive cone. `nonneg a` means that `0 ≤ a` according to
+  the cone. -/
   nonneg : α → Prop
+  /-- The characteristic predicate of a positive cone. `pos a` means that `0 < a` according to
+  the cone. -/
   pos : α → Prop := fun a => nonneg a ∧ ¬nonneg (-a)
   pos_iff : ∀ a, pos a ↔ nonneg a ∧ ¬nonneg (-a) := by intros; rfl
   zero_nonneg : nonneg 0

chore: reduce imports (#9830)

This uses the improved shake script from #9772 to reduce imports across mathlib. The corresponding noshake.json file has been added to #9772.

Co-authored-by: Mario Carneiro <di.gama@gmail.com>

f4c4ca61

Diff

@@ -5,7 +5,7 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
 import Mathlib.Algebra.Order.Monoid.Defs
 import Mathlib.Algebra.Order.Sub.Defs
-import Mathlib.Order.Hom.Basic
+import Mathlib.Util.AssertExists
 
 #align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"

doc(Algebra/Order/Group/Defs): fix typo monoid -> group for LinearOrderedAddCommGroupWithTop (#9266)

cb221686

Diff

@@ -1097,7 +1097,7 @@ addition is monotone. -/
 class LinearOrderedAddCommGroup (α : Type u) extends OrderedAddCommGroup α, LinearOrder α
 #align linear_ordered_add_comm_group LinearOrderedAddCommGroup
 
-/-- A linearly ordered commutative monoid with an additively absorbing `⊤` element.
+/-- A linearly ordered commutative group with an additively absorbing `⊤` element.
   Instances should include number systems with an infinite element adjoined. -/
 class LinearOrderedAddCommGroupWithTop (α : Type*) extends LinearOrderedAddCommMonoidWithTop α,
   SubNegMonoid α, Nontrivial α where

chore(Algebra/Order/Group): change simp lemmas (#7867)

608404e3

Diff

@@ -705,7 +705,7 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
-@[to_additive (attr := simp)]
+@[to_additive]
 theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b := by
   simpa only [div_eq_mul_inv] using mul_le_mul_iff_right _
 #align div_le_div_iff_right div_le_div_iff_right
@@ -727,7 +727,7 @@ alias ⟨le_of_sub_nonneg, sub_nonneg_of_le⟩ := sub_nonneg
 #align sub_nonneg_of_le sub_nonneg_of_le
 #align le_of_sub_nonneg le_of_sub_nonneg
 
-@[to_additive (attr := simp) sub_nonpos]
+@[to_additive sub_nonpos]
 theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_one' div_le_one'
@@ -753,6 +753,10 @@ theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c := by
 #align div_le_iff_le_mul div_le_iff_le_mul
 #align sub_le_iff_le_add sub_le_iff_le_add
 
+-- Note: we intentionally don't have `@[simp]` for the additive version,
+-- since the LHS simplifies with `tsub_le_iff_right`
+attribute [simp] div_le_iff_le_mul
+
 -- TODO: Should we get rid of `sub_le_iff_le_add` in favor of
 -- (a renamed version of) `tsub_le_iff_right`?
 -- see Note [lower instance priority]
@@ -769,7 +773,7 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
-@[to_additive (attr := simp)]
+@[to_additive]
 theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_le_mul_iff_left a⁻¹, inv_mul_cancel_left,
     inv_mul_cancel_left, inv_le_inv_iff]
@@ -1070,7 +1074,7 @@ theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
 -- What is the point of this lemma?  See comment about `div_le_inv_mul_iff` above.
 -- Note: we intentionally don't have `@[simp]` for the additive version,
 -- since the LHS simplifies with `tsub_le_iff_right`
-@[to_additive, simp]
+@[to_additive]
 theorem div_le_div_flip {α : Type*} [CommGroup α] [LinearOrder α]
     [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} : a / b ≤ b / a ↔ a ≤ b := by
   rw [div_eq_mul_inv b, mul_comm]

chore(Algebra/Regular/Basic): generalize to IsCancelMul (#8428)

This lets lemmas about cancellative monoids work for cancellative semigroups

Some docstrings have been rewritten, as adjusting the wording was too awkward.

The new .all names are intended to match Commute.all.

aa7a2917

Diff

@@ -60,7 +60,7 @@ instance (priority := 100) OrderedCommGroup.toOrderedCancelCommMonoid [OrderedCo
 #align ordered_add_comm_group.to_ordered_cancel_add_comm_monoid OrderedAddCommGroup.toOrderedCancelAddCommMonoid
 
 example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (· + ·)) (· < ·) :=
-  AddRightCancelSemigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
+  IsRightCancelAdd.covariant_swap_add_lt_of_covariant_swap_add_le α
 
 -- Porting note: this instance is not used,
 -- and causes timeouts after lean4#2210.

feat: Monovariance under algebraic operations (#7648)

Prove a bunch of results relating monovary to algebraic operations in ordered groups.

9772ef6b

Diff

@@ -1018,6 +1018,13 @@ theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c := by
 
 end Preorder
 
+section LinearOrder
+variable [LinearOrder α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
+
+@[to_additive] lemma lt_or_lt_of_div_lt_div : a / d < b / c → a < b ∨ c < d := by
+  contrapose!; exact fun h ↦ div_le_div'' h.1 h.2
+
+end LinearOrder
 end CommGroup
 
 section LinearOrder

chore: Merge back ordered cancellative stuff (#8170)

There really is no reason (mathematically nor import graphically) to have OrderedCancelCommMonoid be defined in a separate file from OrderedCommMonoid.

Also take the opportunity to:

make OrderedCancelCommMonoid extend OrderedCommMonoid
fix capitalisation in instance names
standardise to defining the additive of each structure version first, so that to_additive can be called directly on the multiplicative version
inline at no cost a few auxiliary lemmas

1dfce854

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathlib.Algebra.Order.Monoid.Cancel.Defs
+import Mathlib.Algebra.Order.Monoid.Defs
 import Mathlib.Algebra.Order.Sub.Defs
 import Mathlib.Order.Hom.Basic

fix: fixes of 3 PRs (#8248)

Fixes mistake introduced in #7976 (ping to @alreadydone that you should use @[to_additive (attr := simp)] and not @[to_additive, simp]) and some namespacing mistakes from my own PRs #7337 and #7755

c97b9b00

Diff

@@ -1159,19 +1159,19 @@ instance (priority := 100) LinearOrderedCommGroup.toLinearOrderedCancelCommMonoi
 #align linear_ordered_comm_group.to_linear_ordered_cancel_comm_monoid LinearOrderedCommGroup.toLinearOrderedCancelCommMonoid
 #align linear_ordered_add_comm_group.to_linear_ordered_cancel_add_comm_monoid LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid
 
-@[to_additive, simp]
+@[to_additive (attr := simp)]
 theorem inv_le_self_iff : a⁻¹ ≤ a ↔ 1 ≤ a := by simp [inv_le_iff_one_le_mul']
 #align neg_le_self_iff neg_le_self_iff
 
-@[to_additive, simp]
+@[to_additive (attr := simp)]
 theorem inv_lt_self_iff : a⁻¹ < a ↔ 1 < a := by simp [inv_lt_iff_one_lt_mul]
 #align neg_lt_self_iff neg_lt_self_iff
 
-@[to_additive, simp]
+@[to_additive (attr := simp)]
 theorem le_inv_self_iff : a ≤ a⁻¹ ↔ a ≤ 1 := by simp [← not_iff_not]
 #align le_neg_self_iff le_neg_self_iff
 
-@[to_additive, simp]
+@[to_additive (attr := simp)]
 theorem lt_inv_self_iff : a < a⁻¹ ↔ a < 1 := by simp [← not_iff_not]
 #align lt_neg_self_iff lt_neg_self_iff

refactor: generalize Abs lemmas from rings to groups (#7976)

Four lemmas are moved from Algebra/Order/Monoid/Defs.lean to Algebra/Order/Group/Defs.lean and generalized

Four lemmas are moved from Algebra/Order/Ring/Abs.lean to Algebra/Order/Group/Abs.lean and generalized

Four lemmas are added in Algebra/Order/Monoid/Defs.lean. They're special cases of one_le_pow_iff, but I can't import the file without offending assert_not_exists.

Co-authored-by: Junyan Xu <junyanxu.math@gmail.com>

41b0e9c7

Diff

@@ -1159,6 +1159,22 @@ instance (priority := 100) LinearOrderedCommGroup.toLinearOrderedCancelCommMonoi
 #align linear_ordered_comm_group.to_linear_ordered_cancel_comm_monoid LinearOrderedCommGroup.toLinearOrderedCancelCommMonoid
 #align linear_ordered_add_comm_group.to_linear_ordered_cancel_add_comm_monoid LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid
 
+@[to_additive, simp]
+theorem inv_le_self_iff : a⁻¹ ≤ a ↔ 1 ≤ a := by simp [inv_le_iff_one_le_mul']
+#align neg_le_self_iff neg_le_self_iff
+
+@[to_additive, simp]
+theorem inv_lt_self_iff : a⁻¹ < a ↔ 1 < a := by simp [inv_lt_iff_one_lt_mul]
+#align neg_lt_self_iff neg_lt_self_iff
+
+@[to_additive, simp]
+theorem le_inv_self_iff : a ≤ a⁻¹ ↔ a ≤ 1 := by simp [← not_iff_not]
+#align le_neg_self_iff le_neg_self_iff
+
+@[to_additive, simp]
+theorem lt_inv_self_iff : a < a⁻¹ ↔ a < 1 := by simp [← not_iff_not]
+#align lt_neg_self_iff lt_neg_self_iff
+
 end LinearOrderedCommGroup
 
 namespace AddCommGroup

docs: make sub_neg refer to sub_neg_eq_add (#7104)

I'm not a fan of this naming :/

8435e0dc

Diff

@@ -890,7 +890,7 @@ alias ⟨lt_of_sub_pos, sub_pos_of_lt⟩ := sub_pos
 #align lt_of_sub_pos lt_of_sub_pos
 #align sub_pos_of_lt sub_pos_of_lt
 
-@[to_additive (attr := simp) sub_neg]
+@[to_additive (attr := simp) sub_neg "For `a - -b = a + b`, see `sub_neg_eq_add`."]
 theorem div_lt_one' : a / b < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_one' div_lt_one'

chore: delay import of NeZero until after basic hierarchy (#6970)

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

c161d180

Diff

@@ -1332,3 +1332,8 @@ theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)
 #align strict_anti_on.neg StrictAntiOn.neg
 
 end
+
+/-
+`NeZero` should not be needed at this point in the ordered algebraic hierarchy.
+-/
+assert_not_exists NeZero

chore(Algebra/Order/Group/Defs): 3 line breaks (#6785)

Move 3 line breaks, so that they no longer separate inputs to Co*variantClasses.

d49f95fe

Diff

@@ -46,8 +46,8 @@ attribute [to_additive] OrderedCommGroup
 
 @[to_additive]
 instance OrderedCommGroup.to_covariantClass_left_le (α : Type u) [OrderedCommGroup α] :
-    CovariantClass α α (· * ·)
-      (· ≤ ·) where elim a b c bc := OrderedCommGroup.mul_le_mul_left b c bc a
+    CovariantClass α α (· * ·) (· ≤ ·) where
+      elim a b c bc := OrderedCommGroup.mul_le_mul_left b c bc a
 #align ordered_comm_group.to_covariant_class_left_le OrderedCommGroup.to_covariantClass_left_le
 #align ordered_add_comm_group.to_covariant_class_left_le OrderedAddCommGroup.to_covariantClass_left_le
 
@@ -69,8 +69,8 @@ example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (·
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
 theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCommGroup α] :
-    ContravariantClass α α (· * ·)
-      (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_left' bc a⁻¹
+    ContravariantClass α α (· * ·) (· ≤ ·) where
+      elim a b c bc := by simpa using mul_le_mul_left' bc a⁻¹
 #align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
 #align ordered_add_comm_group.to_contravariant_class_left_le OrderedAddCommGroup.to_contravariantClass_left_le
 
@@ -80,8 +80,8 @@ theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCom
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
 theorem OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedCommGroup α] :
-    ContravariantClass α α (swap (· * ·))
-      (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_right' bc a⁻¹
+    ContravariantClass α α (swap (· * ·)) (· ≤ ·) where
+      elim a b c bc := by simpa using mul_le_mul_right' bc a⁻¹
 #align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_le
 #align ordered_add_comm_group.to_contravariant_class_right_le OrderedAddCommGroup.to_contravariantClass_right_le

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -346,7 +346,7 @@ theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
 #align inv_le_inv_iff inv_le_inv_iff
 #align neg_le_neg_iff neg_le_neg_iff
 
-alias neg_le_neg_iff ↔ le_of_neg_le_neg _
+alias ⟨le_of_neg_le_neg, _⟩ := neg_le_neg_iff
 #align le_of_neg_le_neg le_of_neg_le_neg
 
 @[to_additive]
@@ -368,7 +368,7 @@ theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by
 #align le_div_self_iff le_div_self_iff
 #align le_sub_self_iff le_sub_self_iff
 
-alias sub_le_self_iff ↔ _ sub_le_self
+alias ⟨_, sub_le_self⟩ := sub_le_self_iff
 #align sub_le_self sub_le_self
 
 end TypeclassesLeftRightLE
@@ -395,13 +395,13 @@ theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ := by rw [← inv_lt_inv_iff, inv_in
 #align lt_inv' lt_inv'
 #align lt_neg lt_neg
 
-alias lt_inv' ↔ lt_inv_of_lt_inv _
+alias ⟨lt_inv_of_lt_inv, _⟩ := lt_inv'
 #align lt_inv_of_lt_inv lt_inv_of_lt_inv
 
 attribute [to_additive] lt_inv_of_lt_inv
 #align lt_neg_of_lt_neg lt_neg_of_lt_neg
 
-alias inv_lt' ↔ inv_lt_of_inv_lt' _
+alias ⟨inv_lt_of_inv_lt', _⟩ := inv_lt'
 #align inv_lt_of_inv_lt' inv_lt_of_inv_lt'
 
 attribute [to_additive neg_lt_of_neg_lt] inv_lt_of_inv_lt'
@@ -420,7 +420,7 @@ theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by
 #align div_lt_self_iff div_lt_self_iff
 #align sub_lt_self_iff sub_lt_self_iff
 
-alias sub_lt_self_iff ↔ _ sub_lt_self
+alias ⟨_, sub_lt_self⟩ := sub_lt_self_iff
 #align sub_lt_self sub_lt_self
 
 end TypeclassesLeftRightLT
@@ -439,7 +439,7 @@ theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
 #align left.inv_le_self Left.inv_le_self
 #align left.neg_le_self Left.neg_le_self
 
-alias Left.neg_le_self ← neg_le_self
+alias neg_le_self := Left.neg_le_self
 #align neg_le_self neg_le_self
 
 @[to_additive]
@@ -460,7 +460,7 @@ theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
 #align left.inv_lt_self Left.inv_lt_self
 #align left.neg_lt_self Left.neg_lt_self
 
-alias Left.neg_lt_self ← neg_lt_self
+alias neg_lt_self := Left.neg_lt_self
 #align neg_lt_self neg_lt_self
 
 @[to_additive]
@@ -565,85 +565,85 @@ end LT
 
 end CommGroup
 
-alias Left.inv_le_one_iff ↔ one_le_of_inv_le_one _
+alias ⟨one_le_of_inv_le_one, _⟩ := Left.inv_le_one_iff
 #align one_le_of_inv_le_one one_le_of_inv_le_one
 
 attribute [to_additive] one_le_of_inv_le_one
 #align nonneg_of_neg_nonpos nonneg_of_neg_nonpos
 
-alias Left.one_le_inv_iff ↔ le_one_of_one_le_inv _
+alias ⟨le_one_of_one_le_inv, _⟩ := Left.one_le_inv_iff
 #align le_one_of_one_le_inv le_one_of_one_le_inv
 
 attribute [to_additive nonpos_of_neg_nonneg] le_one_of_one_le_inv
 #align nonpos_of_neg_nonneg nonpos_of_neg_nonneg
 
-alias inv_lt_inv_iff ↔ lt_of_inv_lt_inv _
+alias ⟨lt_of_inv_lt_inv, _⟩ := inv_lt_inv_iff
 #align lt_of_inv_lt_inv lt_of_inv_lt_inv
 
 attribute [to_additive] lt_of_inv_lt_inv
 #align lt_of_neg_lt_neg lt_of_neg_lt_neg
 
-alias Left.inv_lt_one_iff ↔ one_lt_of_inv_lt_one _
+alias ⟨one_lt_of_inv_lt_one, _⟩ := Left.inv_lt_one_iff
 #align one_lt_of_inv_lt_one one_lt_of_inv_lt_one
 
 attribute [to_additive] one_lt_of_inv_lt_one
 #align pos_of_neg_neg pos_of_neg_neg
 
-alias Left.inv_lt_one_iff ← inv_lt_one_iff_one_lt
+alias inv_lt_one_iff_one_lt := Left.inv_lt_one_iff
 #align inv_lt_one_iff_one_lt inv_lt_one_iff_one_lt
 
 attribute [to_additive] inv_lt_one_iff_one_lt
 #align neg_neg_iff_pos neg_neg_iff_pos
 
-alias Left.inv_lt_one_iff ← inv_lt_one'
+alias inv_lt_one' := Left.inv_lt_one_iff
 #align inv_lt_one' inv_lt_one'
 
 attribute [to_additive neg_lt_zero] inv_lt_one'
 #align neg_lt_zero neg_lt_zero
 
-alias Left.one_lt_inv_iff ↔ inv_of_one_lt_inv _
+alias ⟨inv_of_one_lt_inv, _⟩ := Left.one_lt_inv_iff
 #align inv_of_one_lt_inv inv_of_one_lt_inv
 
 attribute [to_additive neg_of_neg_pos] inv_of_one_lt_inv
 #align neg_of_neg_pos neg_of_neg_pos
 
-alias Left.one_lt_inv_iff ↔ _ one_lt_inv_of_inv
+alias ⟨_, one_lt_inv_of_inv⟩ := Left.one_lt_inv_iff
 #align one_lt_inv_of_inv one_lt_inv_of_inv
 
 attribute [to_additive neg_pos_of_neg] one_lt_inv_of_inv
 #align neg_pos_of_neg neg_pos_of_neg
 
-alias le_inv_mul_iff_mul_le ↔ mul_le_of_le_inv_mul _
+alias ⟨mul_le_of_le_inv_mul, _⟩ := le_inv_mul_iff_mul_le
 #align mul_le_of_le_inv_mul mul_le_of_le_inv_mul
 
 attribute [to_additive] mul_le_of_le_inv_mul
 #align add_le_of_le_neg_add add_le_of_le_neg_add
 
-alias le_inv_mul_iff_mul_le ↔ _ le_inv_mul_of_mul_le
+alias ⟨_, le_inv_mul_of_mul_le⟩ := le_inv_mul_iff_mul_le
 #align le_inv_mul_of_mul_le le_inv_mul_of_mul_le
 
 attribute [to_additive] le_inv_mul_of_mul_le
 #align le_neg_add_of_add_le le_neg_add_of_add_le
 
-alias inv_mul_le_iff_le_mul ↔ _ inv_mul_le_of_le_mul
+alias ⟨_, inv_mul_le_of_le_mul⟩ := inv_mul_le_iff_le_mul
 #align inv_mul_le_of_le_mul inv_mul_le_of_le_mul
 
 -- Porting note: was `inv_mul_le_iff_le_mul`
 attribute [to_additive] inv_mul_le_of_le_mul
 
-alias lt_inv_mul_iff_mul_lt ↔ mul_lt_of_lt_inv_mul _
+alias ⟨mul_lt_of_lt_inv_mul, _⟩ := lt_inv_mul_iff_mul_lt
 #align mul_lt_of_lt_inv_mul mul_lt_of_lt_inv_mul
 
 attribute [to_additive] mul_lt_of_lt_inv_mul
 #align add_lt_of_lt_neg_add add_lt_of_lt_neg_add
 
-alias lt_inv_mul_iff_mul_lt ↔ _ lt_inv_mul_of_mul_lt
+alias ⟨_, lt_inv_mul_of_mul_lt⟩ := lt_inv_mul_iff_mul_lt
 #align lt_inv_mul_of_mul_lt lt_inv_mul_of_mul_lt
 
 attribute [to_additive] lt_inv_mul_of_mul_lt
 #align lt_neg_add_of_add_lt lt_neg_add_of_add_lt
 
-alias inv_mul_lt_iff_lt_mul ↔ lt_mul_of_inv_mul_lt inv_mul_lt_of_lt_mul
+alias ⟨lt_mul_of_inv_mul_lt, inv_mul_lt_of_lt_mul⟩ := inv_mul_lt_iff_lt_mul
 #align lt_mul_of_inv_mul_lt lt_mul_of_inv_mul_lt
 #align inv_mul_lt_of_lt_mul inv_mul_lt_of_lt_mul
 
@@ -653,43 +653,43 @@ attribute [to_additive] lt_mul_of_inv_mul_lt
 attribute [to_additive] inv_mul_lt_of_lt_mul
 #align neg_add_lt_of_lt_add neg_add_lt_of_lt_add
 
-alias lt_mul_of_inv_mul_lt ← lt_mul_of_inv_mul_lt_left
+alias lt_mul_of_inv_mul_lt_left := lt_mul_of_inv_mul_lt
 #align lt_mul_of_inv_mul_lt_left lt_mul_of_inv_mul_lt_left
 
 attribute [to_additive] lt_mul_of_inv_mul_lt_left
 #align lt_add_of_neg_add_lt_left lt_add_of_neg_add_lt_left
 
-alias Left.inv_le_one_iff ← inv_le_one'
+alias inv_le_one' := Left.inv_le_one_iff
 #align inv_le_one' inv_le_one'
 
 attribute [to_additive neg_nonpos] inv_le_one'
 #align neg_nonpos neg_nonpos
 
-alias Left.one_le_inv_iff ← one_le_inv'
+alias one_le_inv' := Left.one_le_inv_iff
 #align one_le_inv' one_le_inv'
 
 attribute [to_additive neg_nonneg] one_le_inv'
 #align neg_nonneg neg_nonneg
 
-alias Left.one_lt_inv_iff ← one_lt_inv'
+alias one_lt_inv' := Left.one_lt_inv_iff
 #align one_lt_inv' one_lt_inv'
 
 attribute [to_additive neg_pos] one_lt_inv'
 #align neg_pos neg_pos
 
-alias mul_lt_mul_left' ← OrderedCommGroup.mul_lt_mul_left'
+alias OrderedCommGroup.mul_lt_mul_left' := mul_lt_mul_left'
 #align ordered_comm_group.mul_lt_mul_left' OrderedCommGroup.mul_lt_mul_left'
 
 attribute [to_additive OrderedAddCommGroup.add_lt_add_left] OrderedCommGroup.mul_lt_mul_left'
 #align ordered_add_comm_group.add_lt_add_left OrderedAddCommGroup.add_lt_add_left
 
-alias le_of_mul_le_mul_left' ← OrderedCommGroup.le_of_mul_le_mul_left
+alias OrderedCommGroup.le_of_mul_le_mul_left := le_of_mul_le_mul_left'
 #align ordered_comm_group.le_of_mul_le_mul_left OrderedCommGroup.le_of_mul_le_mul_left
 
 attribute [to_additive] OrderedCommGroup.le_of_mul_le_mul_left
 #align ordered_add_comm_group.le_of_add_le_add_left OrderedAddCommGroup.le_of_add_le_add_left
 
-alias lt_of_mul_lt_mul_left' ← OrderedCommGroup.lt_of_mul_lt_mul_left
+alias OrderedCommGroup.lt_of_mul_lt_mul_left := lt_of_mul_lt_mul_left'
 #align ordered_comm_group.lt_of_mul_lt_mul_left OrderedCommGroup.lt_of_mul_lt_mul_left
 
 attribute [to_additive] OrderedCommGroup.lt_of_mul_lt_mul_left
@@ -723,7 +723,7 @@ theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a := by
 #align one_le_div' one_le_div'
 #align sub_nonneg sub_nonneg
 
-alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
+alias ⟨le_of_sub_nonneg, sub_nonneg_of_le⟩ := sub_nonneg
 #align sub_nonneg_of_le sub_nonneg_of_le
 #align le_of_sub_nonneg le_of_sub_nonneg
 
@@ -733,7 +733,7 @@ theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
 #align div_le_one' div_le_one'
 #align sub_nonpos sub_nonpos
 
-alias sub_nonpos ↔ le_of_sub_nonpos sub_nonpos_of_le
+alias ⟨le_of_sub_nonpos, sub_nonpos_of_le⟩ := sub_nonpos
 #align sub_nonpos_of_le sub_nonpos_of_le
 #align le_of_sub_nonpos le_of_sub_nonpos
 
@@ -743,7 +743,7 @@ theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c := by
 #align le_div_iff_mul_le le_div_iff_mul_le
 #align le_sub_iff_add_le le_sub_iff_add_le
 
-alias le_sub_iff_add_le ↔ add_le_of_le_sub_right le_sub_right_of_add_le
+alias ⟨add_le_of_le_sub_right, le_sub_right_of_add_le⟩ := le_sub_iff_add_le
 #align add_le_of_le_sub_right add_le_of_le_sub_right
 #align le_sub_right_of_add_le le_sub_right_of_add_le
 
@@ -805,7 +805,7 @@ theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c := by rw [le_div_iff_mu
 #align le_div_iff_mul_le' le_div_iff_mul_le'
 #align le_sub_iff_add_le' le_sub_iff_add_le'
 
-alias le_sub_iff_add_le' ↔ add_le_of_le_sub_left le_sub_left_of_add_le
+alias ⟨add_le_of_le_sub_left, le_sub_left_of_add_le⟩ := le_sub_iff_add_le'
 #align le_sub_left_of_add_le le_sub_left_of_add_le
 #align add_le_of_le_sub_left add_le_of_le_sub_left
 
@@ -814,7 +814,7 @@ theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le
 #align div_le_iff_le_mul' div_le_iff_le_mul'
 #align sub_le_iff_le_add' sub_le_iff_le_add'
 
-alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
+alias ⟨le_add_of_sub_left_le, sub_left_le_of_le_add⟩ := sub_le_iff_le_add'
 #align sub_left_le_of_le_add sub_left_le_of_le_add
 #align le_add_of_sub_left_le le_add_of_sub_left_le
 
@@ -886,7 +886,7 @@ theorem one_lt_div' : 1 < a / b ↔ b < a := by
 #align one_lt_div' one_lt_div'
 #align sub_pos sub_pos
 
-alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
+alias ⟨lt_of_sub_pos, sub_pos_of_lt⟩ := sub_pos
 #align lt_of_sub_pos lt_of_sub_pos
 #align sub_pos_of_lt sub_pos_of_lt
 
@@ -896,11 +896,11 @@ theorem div_lt_one' : a / b < 1 ↔ a < b := by
 #align div_lt_one' div_lt_one'
 #align sub_neg sub_neg
 
-alias sub_neg ↔ lt_of_sub_neg sub_neg_of_lt
+alias ⟨lt_of_sub_neg, sub_neg_of_lt⟩ := sub_neg
 #align lt_of_sub_neg lt_of_sub_neg
 #align sub_neg_of_lt sub_neg_of_lt
 
-alias sub_neg ← sub_lt_zero
+alias sub_lt_zero := sub_neg
 #align sub_lt_zero sub_lt_zero
 
 @[to_additive]
@@ -909,7 +909,7 @@ theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c := by
 #align lt_div_iff_mul_lt lt_div_iff_mul_lt
 #align lt_sub_iff_add_lt lt_sub_iff_add_lt
 
-alias lt_sub_iff_add_lt ↔ add_lt_of_lt_sub_right lt_sub_right_of_add_lt
+alias ⟨add_lt_of_lt_sub_right, lt_sub_right_of_add_lt⟩ := lt_sub_iff_add_lt
 #align add_lt_of_lt_sub_right add_lt_of_lt_sub_right
 #align lt_sub_right_of_add_lt lt_sub_right_of_add_lt
 
@@ -919,7 +919,7 @@ theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c := by
 #align div_lt_iff_lt_mul div_lt_iff_lt_mul
 #align sub_lt_iff_lt_add sub_lt_iff_lt_add
 
-alias sub_lt_iff_lt_add ↔ lt_add_of_sub_right_lt sub_right_lt_of_lt_add
+alias ⟨lt_add_of_sub_right_lt, sub_right_lt_of_lt_add⟩ := sub_lt_iff_lt_add
 #align lt_add_of_sub_right_lt lt_add_of_sub_right_lt
 #align sub_right_lt_of_lt_add sub_right_lt_of_lt_add
 
@@ -972,7 +972,7 @@ theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c := by rw [lt_div_iff_mul_lt
 #align lt_div_iff_mul_lt' lt_div_iff_mul_lt'
 #align lt_sub_iff_add_lt' lt_sub_iff_add_lt'
 
-alias lt_sub_iff_add_lt' ↔ add_lt_of_lt_sub_left lt_sub_left_of_add_lt
+alias ⟨add_lt_of_lt_sub_left, lt_sub_left_of_add_lt⟩ := lt_sub_iff_add_lt'
 #align lt_sub_left_of_add_lt lt_sub_left_of_add_lt
 #align add_lt_of_lt_sub_left add_lt_of_lt_sub_left
 
@@ -981,7 +981,7 @@ theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c := by rw [div_lt_iff_lt_mul
 #align div_lt_iff_lt_mul' div_lt_iff_lt_mul'
 #align sub_lt_iff_lt_add' sub_lt_iff_lt_add'
 
-alias sub_lt_iff_lt_add' ↔ lt_add_of_sub_left_lt sub_left_lt_of_lt_add
+alias ⟨lt_add_of_sub_left_lt, sub_left_lt_of_lt_add⟩ := sub_lt_iff_lt_add'
 #align lt_add_of_sub_left_lt lt_add_of_sub_left_lt
 #align sub_left_lt_of_lt_add sub_left_lt_of_lt_add

chore: banish Type _ and Sort _ (#6499)

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

This has nice performance benefits.

32de3f67

Diff

@@ -756,7 +756,7 @@ theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c := by
 -- TODO: Should we get rid of `sub_le_iff_le_add` in favor of
 -- (a renamed version of) `tsub_le_iff_right`?
 -- see Note [lower instance priority]
-instance (priority := 100) AddGroup.toHasOrderedSub {α : Type _} [AddGroup α] [LE α]
+instance (priority := 100) AddGroup.toHasOrderedSub {α : Type*} [AddGroup α] [LE α]
     [CovariantClass α α (swap (· + ·)) (· ≤ ·)] : OrderedSub α :=
   ⟨fun _ _ _ => sub_le_iff_le_add⟩
 #align add_group.to_has_ordered_sub AddGroup.toHasOrderedSub
@@ -1064,7 +1064,7 @@ theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
 -- Note: we intentionally don't have `@[simp]` for the additive version,
 -- since the LHS simplifies with `tsub_le_iff_right`
 @[to_additive, simp]
-theorem div_le_div_flip {α : Type _} [CommGroup α] [LinearOrder α]
+theorem div_le_div_flip {α : Type*} [CommGroup α] [LinearOrder α]
     [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} : a / b ≤ b / a ↔ a ≤ b := by
   rw [div_eq_mul_inv b, mul_comm]
   exact div_le_inv_mul_iff
@@ -1088,7 +1088,7 @@ class LinearOrderedAddCommGroup (α : Type u) extends OrderedAddCommGroup α, Li
 
 /-- A linearly ordered commutative monoid with an additively absorbing `⊤` element.
   Instances should include number systems with an infinite element adjoined. -/
-class LinearOrderedAddCommGroupWithTop (α : Type _) extends LinearOrderedAddCommMonoidWithTop α,
+class LinearOrderedAddCommGroupWithTop (α : Type*) extends LinearOrderedAddCommMonoidWithTop α,
   SubNegMonoid α, Nontrivial α where
   protected neg_top : -(⊤ : α) = ⊤
   protected add_neg_cancel : ∀ a : α, a ≠ ⊤ → a + -a = 0
@@ -1167,7 +1167,7 @@ namespace AddCommGroup
 This is useful for constructing an `OrderedAddCommGroup`
 by choosing a positive cone in an existing `AddCommGroup`. -/
 -- Porting note: @[nolint has_nonempty_instance]
-structure PositiveCone (α : Type _) [AddCommGroup α] where
+structure PositiveCone (α : Type*) [AddCommGroup α] where
   nonneg : α → Prop
   pos : α → Prop := fun a => nonneg a ∧ ¬nonneg (-a)
   pos_iff : ∀ a, pos a ↔ nonneg a ∧ ¬nonneg (-a) := by intros; rfl
@@ -1179,7 +1179,7 @@ structure PositiveCone (α : Type _) [AddCommGroup α] where
 /-- A positive cone in an `AddCommGroup` induces a linear order if
 for every `a`, either `a` or `-a` is non-negative. -/
 -- Porting note: @[nolint has_nonempty_instance]
-structure TotalPositiveCone (α : Type _) [AddCommGroup α] extends PositiveCone α where
+structure TotalPositiveCone (α : Type*) [AddCommGroup α] extends PositiveCone α where
   /-- For any `a` the proposition `nonneg a` is decidable -/
   nonnegDecidable : DecidablePred nonneg
   /-- Either `a` or `-a` is `nonneg` -/
@@ -1198,7 +1198,7 @@ open AddCommGroup
 
 /-- Construct an `OrderedAddCommGroup` by
 designating a positive cone in an existing `AddCommGroup`. -/
-def mkOfPositiveCone {α : Type _} [AddCommGroup α] (C : PositiveCone α) : OrderedAddCommGroup α :=
+def mkOfPositiveCone {α : Type*} [AddCommGroup α] (C : PositiveCone α) : OrderedAddCommGroup α :=
   { ‹AddCommGroup α› with
     le := fun a b => C.nonneg (b - a),
     lt := fun a b => C.pos (b - a),
@@ -1219,7 +1219,7 @@ open AddCommGroup
 /-- Construct a `LinearOrderedAddCommGroup` by
 designating a positive cone in an existing `AddCommGroup`
 such that for every `a`, either `a` or `-a` is non-negative. -/
-def mkOfPositiveCone {α : Type _} [AddCommGroup α] (C : TotalPositiveCone α) :
+def mkOfPositiveCone {α : Type*} [AddCommGroup α] (C : TotalPositiveCone α) :
     LinearOrderedAddCommGroup α :=
   { OrderedAddCommGroup.mkOfPositiveCone C.toPositiveCone with
     -- Porting note: was `C.nonneg_total (b - a)`
@@ -1273,7 +1273,7 @@ end NormNumLemmas
 
 section
 
-variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)]
+variable {β : Type*} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· ≤ ·)]
   [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [Preorder β] {f : β → α} {s : Set β}
 
 @[to_additive]
@@ -1304,7 +1304,7 @@ end
 
 section
 
-variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· < ·)]
+variable {β : Type*} [Group α] [Preorder α] [CovariantClass α α (· * ·) (· < ·)]
   [CovariantClass α α (swap (· * ·)) (· < ·)] [Preorder β] {f : β → α} {s : Set β}
 
 @[to_additive]

chore: script to replace headers with #align_import statements (#5979)

depends on: #5966

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

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-
-! This file was ported from Lean 3 source module algebra.order.group.defs
-! leanprover-community/mathlib commit b599f4e4e5cf1fbcb4194503671d3d9e569c1fce
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.Order.Monoid.Cancel.Defs
 import Mathlib.Algebra.Order.Sub.Defs
 import Mathlib.Order.Hom.Basic
 
+#align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"
+
 /-!
 # Ordered groups

chore: fix backtick in docs (#5077)

I wrote a script to find lines that contain an odd number of backticks

878d95c4

Diff

@@ -1090,7 +1090,7 @@ class LinearOrderedAddCommGroup (α : Type u) extends OrderedAddCommGroup α, Li
 #align linear_ordered_add_comm_group LinearOrderedAddCommGroup
 
 /-- A linearly ordered commutative monoid with an additively absorbing `⊤` element.
-  Instances should include number systems with an infinite element adjoined.` -/
+  Instances should include number systems with an infinite element adjoined. -/
 class LinearOrderedAddCommGroupWithTop (α : Type _) extends LinearOrderedAddCommMonoidWithTop α,
   SubNegMonoid α, Nontrivial α where
   protected neg_top : -(⊤ : α) = ⊤

chore: fix grammar 1/3 (#5001)

All of these are doc fixes

d8caa37d

Diff

@@ -34,14 +34,14 @@ variable {α : Type u}
 /-- An ordered additive commutative group is an additive commutative group
 with a partial order in which addition is strictly monotone. -/
 class OrderedAddCommGroup (α : Type u) extends AddCommGroup α, PartialOrder α where
-  /-- Addition is monotone in a ordered additive commutative group. -/
+  /-- Addition is monotone in an ordered additive commutative group. -/
   protected add_le_add_left : ∀ a b : α, a ≤ b → ∀ c : α, c + a ≤ c + b
 #align ordered_add_comm_group OrderedAddCommGroup
 
-/-- An ordered commutative group is an commutative group
+/-- An ordered commutative group is a commutative group
 with a partial order in which multiplication is strictly monotone. -/
 class OrderedCommGroup (α : Type u) extends CommGroup α, PartialOrder α where
-  /-- Multiplication is monotone in a ordered commutative group. -/
+  /-- Multiplication is monotone in an ordered commutative group. -/
   protected mul_le_mul_left : ∀ a b : α, a ≤ b → ∀ c : α, c * a ≤ c * b
 #align ordered_comm_group OrderedCommGroup

chore: cleanup some simp-related porting notes (#4954)

I was looking on https://github.com/leanprover-community/mathlib4/pull/4933 to see what simp related porting notes I could improve after https://github.com/leanprover/lean4/pull/2266 lands in Lean 4. Mostly things I found could be cleaned up in any case, and so I've moved those into this PR.

There is lots more work to do diagnosing all the simp-related porting notes!

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

aea24d26

Diff

@@ -361,15 +361,13 @@ theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b :
 
 @[to_additive (attr := simp)]
 theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b := by
-  -- Porting note: was `simp [div_eq_mul_inv]`
-  simp only [div_eq_mul_inv, mul_le_iff_le_one_right', Left.inv_le_one_iff]
+  simp [div_eq_mul_inv]
 #align div_le_self_iff div_le_self_iff
 #align sub_le_self_iff sub_le_self_iff
 
 @[to_additive (attr := simp)]
 theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by
-  -- Porting note: was `simp [div_eq_mul_inv]`
-  simp only [div_eq_mul_inv, le_mul_iff_one_le_right', Left.one_le_inv_iff]
+  simp [div_eq_mul_inv]
 #align le_div_self_iff le_div_self_iff
 #align le_sub_self_iff le_sub_self_iff
 
@@ -421,8 +419,7 @@ theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
 
 @[to_additive (attr := simp)]
 theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by
-  -- Porting note: was `simp [div_eq_mul_inv]`
-  simp only [div_eq_mul_inv, mul_lt_iff_lt_one_left', Left.inv_lt_one_iff]
+  simp [div_eq_mul_inv]
 #align div_lt_self_iff div_lt_self_iff
 #align sub_lt_self_iff sub_lt_self_iff

chore: fix typos (#4518)

I ran codespell Mathlib and got tired halfway through the suggestions.

92beef58

Diff

@@ -1171,7 +1171,7 @@ namespace AddCommGroup
 
 /-- A collection of elements in an `AddCommGroup` designated as "non-negative".
 This is useful for constructing an `OrderedAddCommGroup`
-by choosing a positive cone in an exisiting `AddCommGroup`. -/
+by choosing a positive cone in an existing `AddCommGroup`. -/
 -- Porting note: @[nolint has_nonempty_instance]
 structure PositiveCone (α : Type _) [AddCommGroup α] where
   nonneg : α → Prop

chore: reenable eta, bump to nightly 2023-05-16 (#3414)

Now that leanprover/lean4#2210 has been merged, this PR:

removes all the set_option synthInstance.etaExperiment true commands (and some etaExperiment% term elaborators)
removes many but not quite all set_option maxHeartbeats commands
makes various other changes required to cope with leanprover/lean4#2210.

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au> Co-authored-by: Scott Morrison <scott.morrison@gmail.com> Co-authored-by: Matthew Ballard <matt@mrb.email>

a6e1045f

Diff

@@ -66,7 +66,7 @@ example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (·
   AddRightCancelSemigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
 
 -- Porting note: this instance is not used,
--- and causes timeouts when interacting with etaExperiment.
+-- and causes timeouts after lean4#2210.
 -- It was introduced in https://github.com/leanprover-community/mathlib/pull/17564
 -- but without the motivation clearly explained.
 /-- A choice-free shortcut instance. -/
@@ -78,7 +78,7 @@ theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCom
 #align ordered_add_comm_group.to_contravariant_class_left_le OrderedAddCommGroup.to_contravariantClass_left_le
 
 -- Porting note: this instance is not used,
--- and causes timeouts when interacting with etaExperiment.
+-- and causes timeouts after lean4#2210.
 -- See further explanation on `OrderedCommGroup.to_contravariantClass_left_le`.
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]

chore: disable instances causing trouble with etaExperiment (#3905)

Co-authored-by: Scott Morrison <scott.morrison@anu.edu.au>

f5551f22

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 
 ! This file was ported from Lean 3 source module algebra.order.group.defs
-! leanprover-community/mathlib commit 2ed7e4aec72395b6a7c3ac4ac7873a7a43ead17c
+! leanprover-community/mathlib commit b599f4e4e5cf1fbcb4194503671d3d9e569c1fce
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -65,17 +65,24 @@ instance (priority := 100) OrderedCommGroup.toOrderedCancelCommMonoid [OrderedCo
 example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (· + ·)) (· < ·) :=
   AddRightCancelSemigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
 
+-- Porting note: this instance is not used,
+-- and causes timeouts when interacting with etaExperiment.
+-- It was introduced in https://github.com/leanprover-community/mathlib/pull/17564
+-- but without the motivation clearly explained.
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
-instance OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCommGroup α] :
+theorem OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCommGroup α] :
     ContravariantClass α α (· * ·)
       (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_left' bc a⁻¹
 #align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
 #align ordered_add_comm_group.to_contravariant_class_left_le OrderedAddCommGroup.to_contravariantClass_left_le
 
+-- Porting note: this instance is not used,
+-- and causes timeouts when interacting with etaExperiment.
+-- See further explanation on `OrderedCommGroup.to_contravariantClass_left_le`.
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
-instance OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedCommGroup α] :
+theorem OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedCommGroup α] :
     ContravariantClass α α (swap (· * ·))
       (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_right' bc a⁻¹
 #align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_le

fix: correct names of LinearOrder decidable fields (#4006)

This renames

decidable_eq to decidableEq
decidable_lt to decidableLT
decidable_le to decidableLE
decidableLT_of_decidableLE to decidableLTOfDecidableLE
decidableEq_of_decidableLE to decidableEqOfDecidableLE

These fields are data not proofs, so they should be lowerCamelCased.

e7280432

Diff

@@ -1223,7 +1223,7 @@ def mkOfPositiveCone {α : Type _} [AddCommGroup α] (C : TotalPositiveCone α)
   { OrderedAddCommGroup.mkOfPositiveCone C.toPositiveCone with
     -- Porting note: was `C.nonneg_total (b - a)`
     le_total := fun a b => by simpa [neg_sub] using C.nonneg_total (b - a)
-    decidable_le := fun a b => C.nonnegDecidable _ }
+    decidableLE := fun a b => C.nonnegDecidable _ }
 #align linear_ordered_add_comm_group.mk_of_positive_cone LinearOrderedAddCommGroup.mkOfPositiveCone
 
 end LinearOrderedAddCommGroup

chore: add missing #align statements (#1902)

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

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

b72bb858

Diff

@@ -343,6 +343,7 @@ theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
 #align neg_le_neg_iff neg_le_neg_iff
 
 alias neg_le_neg_iff ↔ le_of_neg_le_neg _
+#align le_of_neg_le_neg le_of_neg_le_neg
 
 @[to_additive]
 theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b := by
@@ -366,6 +367,7 @@ theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by
 #align le_sub_self_iff le_sub_self_iff
 
 alias sub_le_self_iff ↔ _ sub_le_self
+#align sub_le_self sub_le_self
 
 end TypeclassesLeftRightLE
 
@@ -392,12 +394,16 @@ theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ := by rw [← inv_lt_inv_iff, inv_in
 #align lt_neg lt_neg
 
 alias lt_inv' ↔ lt_inv_of_lt_inv _
+#align lt_inv_of_lt_inv lt_inv_of_lt_inv
 
 attribute [to_additive] lt_inv_of_lt_inv
+#align lt_neg_of_lt_neg lt_neg_of_lt_neg
 
 alias inv_lt' ↔ inv_lt_of_inv_lt' _
+#align inv_lt_of_inv_lt' inv_lt_of_inv_lt'
 
 attribute [to_additive neg_lt_of_neg_lt] inv_lt_of_inv_lt'
+#align neg_lt_of_neg_lt neg_lt_of_neg_lt
 
 @[to_additive]
 theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
@@ -414,6 +420,7 @@ theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by
 #align sub_lt_self_iff sub_lt_self_iff
 
 alias sub_lt_self_iff ↔ _ sub_lt_self
+#align sub_lt_self sub_lt_self
 
 end TypeclassesLeftRightLT
 
@@ -432,6 +439,7 @@ theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
 #align left.neg_le_self Left.neg_le_self
 
 alias Left.neg_le_self ← neg_le_self
+#align neg_le_self neg_le_self
 
 @[to_additive]
 theorem Left.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ :=
@@ -452,6 +460,7 @@ theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
 #align left.neg_lt_self Left.neg_lt_self
 
 alias Left.neg_lt_self ← neg_lt_self
+#align neg_lt_self neg_lt_self
 
 @[to_additive]
 theorem Left.self_lt_inv (h : a < 1) : a < a⁻¹ :=
@@ -556,91 +565,134 @@ end LT
 end CommGroup
 
 alias Left.inv_le_one_iff ↔ one_le_of_inv_le_one _
+#align one_le_of_inv_le_one one_le_of_inv_le_one
 
 attribute [to_additive] one_le_of_inv_le_one
+#align nonneg_of_neg_nonpos nonneg_of_neg_nonpos
 
 alias Left.one_le_inv_iff ↔ le_one_of_one_le_inv _
+#align le_one_of_one_le_inv le_one_of_one_le_inv
 
 attribute [to_additive nonpos_of_neg_nonneg] le_one_of_one_le_inv
+#align nonpos_of_neg_nonneg nonpos_of_neg_nonneg
 
 alias inv_lt_inv_iff ↔ lt_of_inv_lt_inv _
+#align lt_of_inv_lt_inv lt_of_inv_lt_inv
 
 attribute [to_additive] lt_of_inv_lt_inv
+#align lt_of_neg_lt_neg lt_of_neg_lt_neg
 
 alias Left.inv_lt_one_iff ↔ one_lt_of_inv_lt_one _
+#align one_lt_of_inv_lt_one one_lt_of_inv_lt_one
 
 attribute [to_additive] one_lt_of_inv_lt_one
+#align pos_of_neg_neg pos_of_neg_neg
 
 alias Left.inv_lt_one_iff ← inv_lt_one_iff_one_lt
+#align inv_lt_one_iff_one_lt inv_lt_one_iff_one_lt
 
 attribute [to_additive] inv_lt_one_iff_one_lt
+#align neg_neg_iff_pos neg_neg_iff_pos
 
 alias Left.inv_lt_one_iff ← inv_lt_one'
+#align inv_lt_one' inv_lt_one'
 
 attribute [to_additive neg_lt_zero] inv_lt_one'
+#align neg_lt_zero neg_lt_zero
 
 alias Left.one_lt_inv_iff ↔ inv_of_one_lt_inv _
+#align inv_of_one_lt_inv inv_of_one_lt_inv
 
 attribute [to_additive neg_of_neg_pos] inv_of_one_lt_inv
+#align neg_of_neg_pos neg_of_neg_pos
 
 alias Left.one_lt_inv_iff ↔ _ one_lt_inv_of_inv
+#align one_lt_inv_of_inv one_lt_inv_of_inv
 
 attribute [to_additive neg_pos_of_neg] one_lt_inv_of_inv
+#align neg_pos_of_neg neg_pos_of_neg
 
 alias le_inv_mul_iff_mul_le ↔ mul_le_of_le_inv_mul _
+#align mul_le_of_le_inv_mul mul_le_of_le_inv_mul
 
 attribute [to_additive] mul_le_of_le_inv_mul
+#align add_le_of_le_neg_add add_le_of_le_neg_add
 
 alias le_inv_mul_iff_mul_le ↔ _ le_inv_mul_of_mul_le
+#align le_inv_mul_of_mul_le le_inv_mul_of_mul_le
 
 attribute [to_additive] le_inv_mul_of_mul_le
+#align le_neg_add_of_add_le le_neg_add_of_add_le
 
 alias inv_mul_le_iff_le_mul ↔ _ inv_mul_le_of_le_mul
+#align inv_mul_le_of_le_mul inv_mul_le_of_le_mul
 
 -- Porting note: was `inv_mul_le_iff_le_mul`
 attribute [to_additive] inv_mul_le_of_le_mul
 
 alias lt_inv_mul_iff_mul_lt ↔ mul_lt_of_lt_inv_mul _
+#align mul_lt_of_lt_inv_mul mul_lt_of_lt_inv_mul
 
 attribute [to_additive] mul_lt_of_lt_inv_mul
+#align add_lt_of_lt_neg_add add_lt_of_lt_neg_add
 
 alias lt_inv_mul_iff_mul_lt ↔ _ lt_inv_mul_of_mul_lt
+#align lt_inv_mul_of_mul_lt lt_inv_mul_of_mul_lt
 
 attribute [to_additive] lt_inv_mul_of_mul_lt
+#align lt_neg_add_of_add_lt lt_neg_add_of_add_lt
 
 alias inv_mul_lt_iff_lt_mul ↔ lt_mul_of_inv_mul_lt inv_mul_lt_of_lt_mul
+#align lt_mul_of_inv_mul_lt lt_mul_of_inv_mul_lt
+#align inv_mul_lt_of_lt_mul inv_mul_lt_of_lt_mul
 
 attribute [to_additive] lt_mul_of_inv_mul_lt
+#align lt_add_of_neg_add_lt lt_add_of_neg_add_lt
 
 attribute [to_additive] inv_mul_lt_of_lt_mul
+#align neg_add_lt_of_lt_add neg_add_lt_of_lt_add
 
 alias lt_mul_of_inv_mul_lt ← lt_mul_of_inv_mul_lt_left
+#align lt_mul_of_inv_mul_lt_left lt_mul_of_inv_mul_lt_left
 
 attribute [to_additive] lt_mul_of_inv_mul_lt_left
+#align lt_add_of_neg_add_lt_left lt_add_of_neg_add_lt_left
 
 alias Left.inv_le_one_iff ← inv_le_one'
+#align inv_le_one' inv_le_one'
 
 attribute [to_additive neg_nonpos] inv_le_one'
+#align neg_nonpos neg_nonpos
 
 alias Left.one_le_inv_iff ← one_le_inv'
+#align one_le_inv' one_le_inv'
 
 attribute [to_additive neg_nonneg] one_le_inv'
+#align neg_nonneg neg_nonneg
 
 alias Left.one_lt_inv_iff ← one_lt_inv'
+#align one_lt_inv' one_lt_inv'
 
 attribute [to_additive neg_pos] one_lt_inv'
+#align neg_pos neg_pos
 
 alias mul_lt_mul_left' ← OrderedCommGroup.mul_lt_mul_left'
+#align ordered_comm_group.mul_lt_mul_left' OrderedCommGroup.mul_lt_mul_left'
 
 attribute [to_additive OrderedAddCommGroup.add_lt_add_left] OrderedCommGroup.mul_lt_mul_left'
+#align ordered_add_comm_group.add_lt_add_left OrderedAddCommGroup.add_lt_add_left
 
 alias le_of_mul_le_mul_left' ← OrderedCommGroup.le_of_mul_le_mul_left
+#align ordered_comm_group.le_of_mul_le_mul_left OrderedCommGroup.le_of_mul_le_mul_left
 
 attribute [to_additive] OrderedCommGroup.le_of_mul_le_mul_left
+#align ordered_add_comm_group.le_of_add_le_add_left OrderedAddCommGroup.le_of_add_le_add_left
 
 alias lt_of_mul_lt_mul_left' ← OrderedCommGroup.lt_of_mul_lt_mul_left
+#align ordered_comm_group.lt_of_mul_lt_mul_left OrderedCommGroup.lt_of_mul_lt_mul_left
 
 attribute [to_additive] OrderedCommGroup.lt_of_mul_lt_mul_left
+#align ordered_add_comm_group.lt_of_add_lt_add_left OrderedAddCommGroup.lt_of_add_lt_add_left
 
 --  Most of the lemmas that are primed in this section appear in ordered_field.
 --  I (DT) did not try to minimise the assumptions.
@@ -671,6 +723,8 @@ theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a := by
 #align sub_nonneg sub_nonneg
 
 alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
+#align sub_nonneg_of_le sub_nonneg_of_le
+#align le_of_sub_nonneg le_of_sub_nonneg
 
 @[to_additive (attr := simp) sub_nonpos]
 theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
@@ -679,6 +733,8 @@ theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
 #align sub_nonpos sub_nonpos
 
 alias sub_nonpos ↔ le_of_sub_nonpos sub_nonpos_of_le
+#align sub_nonpos_of_le sub_nonpos_of_le
+#align le_of_sub_nonpos le_of_sub_nonpos
 
 @[to_additive]
 theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c := by
@@ -687,6 +743,8 @@ theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c := by
 #align le_sub_iff_add_le le_sub_iff_add_le
 
 alias le_sub_iff_add_le ↔ add_le_of_le_sub_right le_sub_right_of_add_le
+#align add_le_of_le_sub_right add_le_of_le_sub_right
+#align le_sub_right_of_add_le le_sub_right_of_add_le
 
 @[to_additive]
 theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c := by
@@ -747,6 +805,8 @@ theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c := by rw [le_div_iff_mu
 #align le_sub_iff_add_le' le_sub_iff_add_le'
 
 alias le_sub_iff_add_le' ↔ add_le_of_le_sub_left le_sub_left_of_add_le
+#align le_sub_left_of_add_le le_sub_left_of_add_le
+#align add_le_of_le_sub_left add_le_of_le_sub_left
 
 @[to_additive]
 theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le_mul, mul_comm]
@@ -754,6 +814,8 @@ theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le
 #align sub_le_iff_le_add' sub_le_iff_le_add'
 
 alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
+#align sub_left_le_of_le_add sub_left_le_of_le_add
+#align le_add_of_sub_left_le le_add_of_sub_left_le
 
 @[to_additive (attr := simp)]
 theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b :=
@@ -824,6 +886,8 @@ theorem one_lt_div' : 1 < a / b ↔ b < a := by
 #align sub_pos sub_pos
 
 alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
+#align lt_of_sub_pos lt_of_sub_pos
+#align sub_pos_of_lt sub_pos_of_lt
 
 @[to_additive (attr := simp) sub_neg]
 theorem div_lt_one' : a / b < 1 ↔ a < b := by
@@ -832,8 +896,11 @@ theorem div_lt_one' : a / b < 1 ↔ a < b := by
 #align sub_neg sub_neg
 
 alias sub_neg ↔ lt_of_sub_neg sub_neg_of_lt
+#align lt_of_sub_neg lt_of_sub_neg
+#align sub_neg_of_lt sub_neg_of_lt
 
 alias sub_neg ← sub_lt_zero
+#align sub_lt_zero sub_lt_zero
 
 @[to_additive]
 theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c := by
@@ -842,6 +909,8 @@ theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c := by
 #align lt_sub_iff_add_lt lt_sub_iff_add_lt
 
 alias lt_sub_iff_add_lt ↔ add_lt_of_lt_sub_right lt_sub_right_of_add_lt
+#align add_lt_of_lt_sub_right add_lt_of_lt_sub_right
+#align lt_sub_right_of_add_lt lt_sub_right_of_add_lt
 
 @[to_additive]
 theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c := by
@@ -850,6 +919,8 @@ theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c := by
 #align sub_lt_iff_lt_add sub_lt_iff_lt_add
 
 alias sub_lt_iff_lt_add ↔ lt_add_of_sub_right_lt sub_right_lt_of_lt_add
+#align lt_add_of_sub_right_lt lt_add_of_sub_right_lt
+#align sub_right_lt_of_lt_add sub_right_lt_of_lt_add
 
 end Right
 
@@ -901,6 +972,8 @@ theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c := by rw [lt_div_iff_mul_lt
 #align lt_sub_iff_add_lt' lt_sub_iff_add_lt'
 
 alias lt_sub_iff_add_lt' ↔ add_lt_of_lt_sub_left lt_sub_left_of_add_lt
+#align lt_sub_left_of_add_lt lt_sub_left_of_add_lt
+#align add_lt_of_lt_sub_left add_lt_of_lt_sub_left
 
 @[to_additive]
 theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c := by rw [div_lt_iff_lt_mul, mul_comm]
@@ -908,6 +981,8 @@ theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c := by rw [div_lt_iff_lt_mul
 #align sub_lt_iff_lt_add' sub_lt_iff_lt_add'
 
 alias sub_lt_iff_lt_add' ↔ lt_add_of_sub_left_lt sub_left_lt_of_lt_add
+#align lt_add_of_sub_left_lt lt_add_of_sub_left_lt
+#align sub_left_lt_of_lt_add sub_left_lt_of_lt_add
 
 @[to_additive]
 theorem inv_lt_div_iff_lt_mul' : b⁻¹ < a / c ↔ c < a * b :=
@@ -1112,6 +1187,7 @@ structure TotalPositiveCone (α : Type _) [AddCommGroup α] extends PositiveCone
 
 /-- Forget that a `TotalPositiveCone` is total. -/
 add_decl_doc TotalPositiveCone.toPositiveCone
+#align add_comm_group.total_positive_cone.to_positive_cone AddCommGroup.TotalPositiveCone.toPositiveCone
 
 end AddCommGroup

chore: add #align statements for to_additive decls (#1816)

Co-authored-by: Floris van Doorn <fpvdoorn@gmail.com>

ed378238

Diff

@@ -52,6 +52,7 @@ instance OrderedCommGroup.to_covariantClass_left_le (α : Type u) [OrderedCommGr
     CovariantClass α α (· * ·)
       (· ≤ ·) where elim a b c bc := OrderedCommGroup.mul_le_mul_left b c bc a
 #align ordered_comm_group.to_covariant_class_left_le OrderedCommGroup.to_covariantClass_left_le
+#align ordered_add_comm_group.to_covariant_class_left_le OrderedAddCommGroup.to_covariantClass_left_le
 
 -- See note [lower instance priority]
 @[to_additive OrderedAddCommGroup.toOrderedCancelAddCommMonoid]
@@ -70,6 +71,7 @@ instance OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCo
     ContravariantClass α α (· * ·)
       (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_left' bc a⁻¹
 #align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
+#align ordered_add_comm_group.to_contravariant_class_left_le OrderedAddCommGroup.to_contravariantClass_left_le
 
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
@@ -77,6 +79,7 @@ instance OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedC
     ContravariantClass α α (swap (· * ·))
       (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_right' bc a⁻¹
 #align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_le
+#align ordered_add_comm_group.to_contravariant_class_right_le OrderedAddCommGroup.to_contravariantClass_right_le
 
 section Group
 
@@ -92,6 +95,7 @@ theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by
   rw [← mul_le_mul_iff_left a]
   simp
 #align left.inv_le_one_iff Left.inv_le_one_iff
+#align left.neg_nonpos_iff Left.neg_nonpos_iff
 
 /-- Uses `left` co(ntra)variant. -/
 @[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
@@ -99,38 +103,45 @@ theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by
   rw [← mul_le_mul_iff_left a]
   simp
 #align left.one_le_inv_iff Left.one_le_inv_iff
+#align left.nonneg_neg_iff Left.nonneg_neg_iff
 
 @[to_additive (attr := simp)]
 theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c := by
   rw [← mul_le_mul_iff_left a]
   simp
 #align le_inv_mul_iff_mul_le le_inv_mul_iff_mul_le
+#align le_neg_add_iff_add_le le_neg_add_iff_add_le
 
 @[to_additive (attr := simp)]
 theorem inv_mul_le_iff_le_mul : b⁻¹ * a ≤ c ↔ a ≤ b * c := by
   rw [← mul_le_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_le_iff_le_mul inv_mul_le_iff_le_mul
+#align neg_add_le_iff_le_add neg_add_le_iff_le_add
 
 @[to_additive neg_le_iff_add_nonneg']
 theorem inv_le_iff_one_le_mul' : a⁻¹ ≤ b ↔ 1 ≤ a * b :=
   (mul_le_mul_iff_left a).symm.trans <| by rw [mul_inv_self]
 #align inv_le_iff_one_le_mul' inv_le_iff_one_le_mul'
+#align neg_le_iff_add_nonneg' neg_le_iff_add_nonneg'
 
 @[to_additive]
 theorem le_inv_iff_mul_le_one_left : a ≤ b⁻¹ ↔ b * a ≤ 1 :=
   (mul_le_mul_iff_left b).symm.trans <| by rw [mul_inv_self]
 #align le_inv_iff_mul_le_one_left le_inv_iff_mul_le_one_left
+#align le_neg_iff_add_nonpos_left le_neg_iff_add_nonpos_left
 
 @[to_additive]
 theorem le_inv_mul_iff_le : 1 ≤ b⁻¹ * a ↔ b ≤ a := by
   rw [← mul_le_mul_iff_left b, mul_one, mul_inv_cancel_left]
 #align le_inv_mul_iff_le le_inv_mul_iff_le
+#align le_neg_add_iff_le le_neg_add_iff_le
 
 @[to_additive]
 theorem inv_mul_le_one_iff : a⁻¹ * b ≤ 1 ↔ b ≤ a :=
   -- Porting note: why is the `_root_` needed?
   _root_.trans inv_mul_le_iff_le_mul <| by rw [mul_one]
 #align inv_mul_le_one_iff inv_mul_le_one_iff
+#align neg_add_nonpos_iff neg_add_nonpos_iff
 
 end TypeclassesLeftLE
 
@@ -143,43 +154,51 @@ variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c : α}
 theorem Left.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
   rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
 #align left.one_lt_inv_iff Left.one_lt_inv_iff
+#align left.neg_pos_iff Left.neg_pos_iff
 
 /-- Uses `left` co(ntra)variant. -/
 @[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
 theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
   rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
 #align left.inv_lt_one_iff Left.inv_lt_one_iff
+#align left.neg_neg_iff Left.neg_neg_iff
 
 @[to_additive (attr := simp)]
 theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c := by
   rw [← mul_lt_mul_iff_left a]
   simp
 #align lt_inv_mul_iff_mul_lt lt_inv_mul_iff_mul_lt
+#align lt_neg_add_iff_add_lt lt_neg_add_iff_add_lt
 
 @[to_additive (attr := simp)]
 theorem inv_mul_lt_iff_lt_mul : b⁻¹ * a < c ↔ a < b * c := by
   rw [← mul_lt_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_lt_iff_lt_mul inv_mul_lt_iff_lt_mul
+#align neg_add_lt_iff_lt_add neg_add_lt_iff_lt_add
 
 @[to_additive]
 theorem inv_lt_iff_one_lt_mul' : a⁻¹ < b ↔ 1 < a * b :=
   (mul_lt_mul_iff_left a).symm.trans <| by rw [mul_inv_self]
 #align inv_lt_iff_one_lt_mul' inv_lt_iff_one_lt_mul'
+#align neg_lt_iff_pos_add' neg_lt_iff_pos_add'
 
 @[to_additive]
 theorem lt_inv_iff_mul_lt_one' : a < b⁻¹ ↔ b * a < 1 :=
   (mul_lt_mul_iff_left b).symm.trans <| by rw [mul_inv_self]
 #align lt_inv_iff_mul_lt_one' lt_inv_iff_mul_lt_one'
+#align lt_neg_iff_add_neg' lt_neg_iff_add_neg'
 
 @[to_additive]
 theorem lt_inv_mul_iff_lt : 1 < b⁻¹ * a ↔ b < a := by
   rw [← mul_lt_mul_iff_left b, mul_one, mul_inv_cancel_left]
 #align lt_inv_mul_iff_lt lt_inv_mul_iff_lt
+#align lt_neg_add_iff_lt lt_neg_add_iff_lt
 
 @[to_additive]
 theorem inv_mul_lt_one_iff : a⁻¹ * b < 1 ↔ b < a :=
   _root_.trans inv_mul_lt_iff_lt_mul <| by rw [mul_one]
 #align inv_mul_lt_one_iff inv_mul_lt_one_iff
+#align neg_add_neg_iff neg_add_neg_iff
 
 end TypeclassesLeftLT
 
@@ -193,6 +212,7 @@ theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by
   rw [← mul_le_mul_iff_right a]
   simp
 #align right.inv_le_one_iff Right.inv_le_one_iff
+#align right.neg_nonpos_iff Right.neg_nonpos_iff
 
 /-- Uses `right` co(ntra)variant. -/
 @[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
@@ -200,42 +220,50 @@ theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by
   rw [← mul_le_mul_iff_right a]
   simp
 #align right.one_le_inv_iff Right.one_le_inv_iff
+#align right.nonneg_neg_iff Right.nonneg_neg_iff
 
 @[to_additive neg_le_iff_add_nonneg]
 theorem inv_le_iff_one_le_mul : a⁻¹ ≤ b ↔ 1 ≤ b * a :=
   (mul_le_mul_iff_right a).symm.trans <| by rw [inv_mul_self]
 #align inv_le_iff_one_le_mul inv_le_iff_one_le_mul
+#align neg_le_iff_add_nonneg neg_le_iff_add_nonneg
 
 @[to_additive]
 theorem le_inv_iff_mul_le_one_right : a ≤ b⁻¹ ↔ a * b ≤ 1 :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align le_inv_iff_mul_le_one_right le_inv_iff_mul_le_one_right
+#align le_neg_iff_add_nonpos_right le_neg_iff_add_nonpos_right
 
 @[to_additive (attr := simp)]
 theorem mul_inv_le_iff_le_mul : a * b⁻¹ ≤ c ↔ a ≤ c * b :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align mul_inv_le_iff_le_mul mul_inv_le_iff_le_mul
+#align add_neg_le_iff_le_add add_neg_le_iff_le_add
 
 @[to_additive (attr := simp)]
 theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align le_mul_inv_iff_mul_le le_mul_inv_iff_mul_le
+#align le_add_neg_iff_add_le le_add_neg_iff_add_le
 
 -- Porting note: `simp` can prove this
 @[to_additive]
 theorem mul_inv_le_one_iff_le : a * b⁻¹ ≤ 1 ↔ a ≤ b :=
   mul_inv_le_iff_le_mul.trans <| by rw [one_mul]
 #align mul_inv_le_one_iff_le mul_inv_le_one_iff_le
+#align add_neg_nonpos_iff_le add_neg_nonpos_iff_le
 
 @[to_additive]
 theorem le_mul_inv_iff_le : 1 ≤ a * b⁻¹ ↔ b ≤ a := by
   rw [← mul_le_mul_iff_right b, one_mul, inv_mul_cancel_right]
 #align le_mul_inv_iff_le le_mul_inv_iff_le
+#align le_add_neg_iff_le le_add_neg_iff_le
 
 @[to_additive]
 theorem mul_inv_le_one_iff : b * a⁻¹ ≤ 1 ↔ b ≤ a :=
   _root_.trans mul_inv_le_iff_le_mul <| by rw [one_mul]
 #align mul_inv_le_one_iff mul_inv_le_one_iff
+#align add_neg_nonpos_iff add_neg_nonpos_iff
 
 end TypeclassesRightLE
 
@@ -248,48 +276,57 @@ variable [LT α] [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c : α}
 theorem Right.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
   rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
 #align right.inv_lt_one_iff Right.inv_lt_one_iff
+#align right.neg_neg_iff Right.neg_neg_iff
 
 /-- Uses `right` co(ntra)variant. -/
 @[to_additive (attr := simp) Right.neg_pos_iff "Uses `right` co(ntra)variant."]
 theorem Right.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
   rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
 #align right.one_lt_inv_iff Right.one_lt_inv_iff
+#align right.neg_pos_iff Right.neg_pos_iff
 
 @[to_additive]
 theorem inv_lt_iff_one_lt_mul : a⁻¹ < b ↔ 1 < b * a :=
   (mul_lt_mul_iff_right a).symm.trans <| by rw [inv_mul_self]
 #align inv_lt_iff_one_lt_mul inv_lt_iff_one_lt_mul
+#align neg_lt_iff_pos_add neg_lt_iff_pos_add
 
 @[to_additive]
 theorem lt_inv_iff_mul_lt_one : a < b⁻¹ ↔ a * b < 1 :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align lt_inv_iff_mul_lt_one lt_inv_iff_mul_lt_one
+#align lt_neg_iff_add_neg lt_neg_iff_add_neg
 
 @[to_additive (attr := simp)]
 theorem mul_inv_lt_iff_lt_mul : a * b⁻¹ < c ↔ a < c * b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right]
 #align mul_inv_lt_iff_lt_mul mul_inv_lt_iff_lt_mul
+#align add_neg_lt_iff_lt_add add_neg_lt_iff_lt_add
 
 @[to_additive (attr := simp)]
 theorem lt_mul_inv_iff_mul_lt : c < a * b⁻¹ ↔ c * b < a :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align lt_mul_inv_iff_mul_lt lt_mul_inv_iff_mul_lt
+#align lt_add_neg_iff_add_lt lt_add_neg_iff_add_lt
 
 -- Porting note: `simp` can prove this
 @[to_additive]
 theorem inv_mul_lt_one_iff_lt : a * b⁻¹ < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right, one_mul]
 #align inv_mul_lt_one_iff_lt inv_mul_lt_one_iff_lt
+#align neg_add_neg_iff_lt neg_add_neg_iff_lt
 
 @[to_additive]
 theorem lt_mul_inv_iff_lt : 1 < a * b⁻¹ ↔ b < a := by
   rw [← mul_lt_mul_iff_right b, one_mul, inv_mul_cancel_right]
 #align lt_mul_inv_iff_lt lt_mul_inv_iff_lt
+#align lt_add_neg_iff_lt lt_add_neg_iff_lt
 
 @[to_additive]
 theorem mul_inv_lt_one_iff : b * a⁻¹ < 1 ↔ b < a :=
   _root_.trans mul_inv_lt_iff_lt_mul <| by rw [one_mul]
 #align mul_inv_lt_one_iff mul_inv_lt_one_iff
+#align add_neg_neg_iff add_neg_neg_iff
 
 end TypeclassesRightLT
 
@@ -303,6 +340,7 @@ theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
   rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]
   simp
 #align inv_le_inv_iff inv_le_inv_iff
+#align neg_le_neg_iff neg_le_neg_iff
 
 alias neg_le_neg_iff ↔ le_of_neg_le_neg _
 
@@ -311,18 +349,21 @@ theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b :
   rw [← mul_le_mul_iff_left d, ← mul_le_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
     inv_mul_cancel_right]
 #align mul_inv_le_inv_mul_iff mul_inv_le_inv_mul_iff
+#align add_neg_le_neg_add_iff add_neg_le_neg_add_iff
 
 @[to_additive (attr := simp)]
 theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b := by
   -- Porting note: was `simp [div_eq_mul_inv]`
   simp only [div_eq_mul_inv, mul_le_iff_le_one_right', Left.inv_le_one_iff]
 #align div_le_self_iff div_le_self_iff
+#align sub_le_self_iff sub_le_self_iff
 
 @[to_additive (attr := simp)]
 theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by
   -- Porting note: was `simp [div_eq_mul_inv]`
   simp only [div_eq_mul_inv, le_mul_iff_one_le_right', Left.one_le_inv_iff]
 #align le_div_self_iff le_div_self_iff
+#align le_sub_self_iff le_sub_self_iff
 
 alias sub_le_self_iff ↔ _ sub_le_self
 
@@ -338,14 +379,17 @@ theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a := by
   rw [← mul_lt_mul_iff_left a, ← mul_lt_mul_iff_right b]
   simp
 #align inv_lt_inv_iff inv_lt_inv_iff
+#align neg_lt_neg_iff neg_lt_neg_iff
 
 @[to_additive neg_lt]
 theorem inv_lt' : a⁻¹ < b ↔ b⁻¹ < a := by rw [← inv_lt_inv_iff, inv_inv]
 #align inv_lt' inv_lt'
+#align neg_lt neg_lt
 
 @[to_additive lt_neg]
 theorem lt_inv' : a < b⁻¹ ↔ b < a⁻¹ := by rw [← inv_lt_inv_iff, inv_inv]
 #align lt_inv' lt_inv'
+#align lt_neg lt_neg
 
 alias lt_inv' ↔ lt_inv_of_lt_inv _
 
@@ -360,12 +404,14 @@ theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
   rw [← mul_lt_mul_iff_left d, ← mul_lt_mul_iff_right b, mul_inv_cancel_left, mul_assoc,
     inv_mul_cancel_right]
 #align mul_inv_lt_inv_mul_iff mul_inv_lt_inv_mul_iff
+#align add_neg_lt_neg_add_iff add_neg_lt_neg_add_iff
 
 @[to_additive (attr := simp)]
 theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by
   -- Porting note: was `simp [div_eq_mul_inv]`
   simp only [div_eq_mul_inv, mul_lt_iff_lt_one_left', Left.inv_lt_one_iff]
 #align div_lt_self_iff div_lt_self_iff
+#align sub_lt_self_iff sub_lt_self_iff
 
 alias sub_lt_self_iff ↔ _ sub_lt_self
 
@@ -383,6 +429,7 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)] {a : α}
 theorem Left.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
   le_trans (Left.inv_le_one_iff.mpr h) h
 #align left.inv_le_self Left.inv_le_self
+#align left.neg_le_self Left.neg_le_self
 
 alias Left.neg_le_self ← neg_le_self
 
@@ -390,6 +437,7 @@ alias Left.neg_le_self ← neg_le_self
 theorem Left.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ :=
   le_trans h (Left.one_le_inv_iff.mpr h)
 #align left.self_le_inv Left.self_le_inv
+#align left.self_le_neg Left.self_le_neg
 
 end LeftLE
 
@@ -401,6 +449,7 @@ variable [CovariantClass α α (· * ·) (· < ·)] {a : α}
 theorem Left.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
   (Left.inv_lt_one_iff.mpr h).trans h
 #align left.inv_lt_self Left.inv_lt_self
+#align left.neg_lt_self Left.neg_lt_self
 
 alias Left.neg_lt_self ← neg_lt_self
 
@@ -408,6 +457,7 @@ alias Left.neg_lt_self ← neg_lt_self
 theorem Left.self_lt_inv (h : a < 1) : a < a⁻¹ :=
   lt_trans h (Left.one_lt_inv_iff.mpr h)
 #align left.self_lt_inv Left.self_lt_inv
+#align left.self_lt_neg Left.self_lt_neg
 
 end LeftLT
 
@@ -419,11 +469,13 @@ variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a : α}
 theorem Right.inv_le_self (h : 1 ≤ a) : a⁻¹ ≤ a :=
   le_trans (Right.inv_le_one_iff.mpr h) h
 #align right.inv_le_self Right.inv_le_self
+#align right.neg_le_self Right.neg_le_self
 
 @[to_additive]
 theorem Right.self_le_inv (h : a ≤ 1) : a ≤ a⁻¹ :=
   le_trans h (Right.one_le_inv_iff.mpr h)
 #align right.self_le_inv Right.self_le_inv
+#align right.self_le_neg Right.self_le_neg
 
 end RightLE
 
@@ -435,11 +487,13 @@ variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a : α}
 theorem Right.inv_lt_self (h : 1 < a) : a⁻¹ < a :=
   (Right.inv_lt_one_iff.mpr h).trans h
 #align right.inv_lt_self Right.inv_lt_self
+#align right.neg_lt_self Right.neg_lt_self
 
 @[to_additive]
 theorem Right.self_lt_inv (h : a < 1) : a < a⁻¹ :=
   lt_trans h (Right.one_lt_inv_iff.mpr h)
 #align right.self_lt_inv Right.self_lt_inv
+#align right.self_lt_neg Right.self_lt_neg
 
 end RightLT
 
@@ -458,17 +512,20 @@ variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 @[to_additive]
 theorem inv_mul_le_iff_le_mul' : c⁻¹ * a ≤ b ↔ a ≤ b * c := by rw [inv_mul_le_iff_le_mul, mul_comm]
 #align inv_mul_le_iff_le_mul' inv_mul_le_iff_le_mul'
+#align neg_add_le_iff_le_add' neg_add_le_iff_le_add'
 
 -- Porting note: `simp` simplifies LHS to `a ≤ c * b`
 @[to_additive]
 theorem mul_inv_le_iff_le_mul' : a * b⁻¹ ≤ c ↔ a ≤ b * c := by
   rw [← inv_mul_le_iff_le_mul, mul_comm]
 #align mul_inv_le_iff_le_mul' mul_inv_le_iff_le_mul'
+#align add_neg_le_iff_le_add' add_neg_le_iff_le_add'
 
 @[to_additive add_neg_le_add_neg_iff]
 theorem mul_inv_le_mul_inv_iff' : a * b⁻¹ ≤ c * d⁻¹ ↔ a * d ≤ c * b := by
   rw [mul_comm c, mul_inv_le_inv_mul_iff, mul_comm]
 #align mul_inv_le_mul_inv_iff' mul_inv_le_mul_inv_iff'
+#align add_neg_le_add_neg_iff add_neg_le_add_neg_iff
 
 end LE
 
@@ -479,17 +536,20 @@ variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 @[to_additive]
 theorem inv_mul_lt_iff_lt_mul' : c⁻¹ * a < b ↔ a < b * c := by rw [inv_mul_lt_iff_lt_mul, mul_comm]
 #align inv_mul_lt_iff_lt_mul' inv_mul_lt_iff_lt_mul'
+#align neg_add_lt_iff_lt_add' neg_add_lt_iff_lt_add'
 
 -- Porting note: `simp` simplifies LHS to `a < c * b`
 @[to_additive]
 theorem mul_inv_lt_iff_le_mul' : a * b⁻¹ < c ↔ a < b * c := by
   rw [← inv_mul_lt_iff_lt_mul, mul_comm]
 #align mul_inv_lt_iff_le_mul' mul_inv_lt_iff_le_mul'
+#align add_neg_lt_iff_le_add' add_neg_lt_iff_le_add'
 
 @[to_additive add_neg_lt_add_neg_iff]
 theorem mul_inv_lt_mul_inv_iff' : a * b⁻¹ < c * d⁻¹ ↔ a * d < c * b := by
   rw [mul_comm c, mul_inv_lt_inv_mul_iff, mul_comm]
 #align mul_inv_lt_mul_inv_iff' mul_inv_lt_mul_inv_iff'
+#align add_neg_lt_add_neg_iff add_neg_lt_add_neg_iff
 
 end LT
 
@@ -596,16 +656,19 @@ variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b := by
   simpa only [div_eq_mul_inv] using mul_le_mul_iff_right _
 #align div_le_div_iff_right div_le_div_iff_right
+#align sub_le_sub_iff_right sub_le_sub_iff_right
 
 @[to_additive sub_le_sub_right]
 theorem div_le_div_right' (h : a ≤ b) (c : α) : a / c ≤ b / c :=
   (div_le_div_iff_right c).2 h
 #align div_le_div_right' div_le_div_right'
+#align sub_le_sub_right sub_le_sub_right
 
 @[to_additive (attr := simp) sub_nonneg]
 theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_le_div' one_le_div'
+#align sub_nonneg sub_nonneg
 
 alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
 
@@ -613,6 +676,7 @@ alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
 theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_one' div_le_one'
+#align sub_nonpos sub_nonpos
 
 alias sub_nonpos ↔ le_of_sub_nonpos sub_nonpos_of_le
 
@@ -620,6 +684,7 @@ alias sub_nonpos ↔ le_of_sub_nonpos sub_nonpos_of_le
 theorem le_div_iff_mul_le : a ≤ c / b ↔ a * b ≤ c := by
   rw [← mul_le_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
 #align le_div_iff_mul_le le_div_iff_mul_le
+#align le_sub_iff_add_le le_sub_iff_add_le
 
 alias le_sub_iff_add_le ↔ add_le_of_le_sub_right le_sub_right_of_add_le
 
@@ -627,6 +692,7 @@ alias le_sub_iff_add_le ↔ add_le_of_le_sub_right le_sub_right_of_add_le
 theorem div_le_iff_le_mul : a / c ≤ b ↔ a ≤ b * c := by
   rw [← mul_le_mul_iff_right c, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_iff_le_mul div_le_iff_le_mul
+#align sub_le_iff_le_add sub_le_iff_le_add
 
 -- TODO: Should we get rid of `sub_le_iff_le_add` in favor of
 -- (a renamed version of) `tsub_le_iff_right`?
@@ -649,11 +715,13 @@ theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_le_mul_iff_left a⁻¹, inv_mul_cancel_left,
     inv_mul_cancel_left, inv_le_inv_iff]
 #align div_le_div_iff_left div_le_div_iff_left
+#align sub_le_sub_iff_left sub_le_sub_iff_left
 
 @[to_additive sub_le_sub_left]
 theorem div_le_div_left' (h : a ≤ b) (c : α) : c / b ≤ c / a :=
   (div_le_div_iff_left c).2 h
 #align div_le_div_left' div_le_div_left'
+#align sub_le_sub_left sub_le_sub_left
 
 end Left
 
@@ -671,16 +739,19 @@ variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 theorem div_le_div_iff' : a / b ≤ c / d ↔ a * d ≤ c * b := by
   simpa only [div_eq_mul_inv] using mul_inv_le_mul_inv_iff'
 #align div_le_div_iff' div_le_div_iff'
+#align sub_le_sub_iff sub_le_sub_iff
 
 @[to_additive]
 theorem le_div_iff_mul_le' : b ≤ c / a ↔ a * b ≤ c := by rw [le_div_iff_mul_le, mul_comm]
 #align le_div_iff_mul_le' le_div_iff_mul_le'
+#align le_sub_iff_add_le' le_sub_iff_add_le'
 
 alias le_sub_iff_add_le' ↔ add_le_of_le_sub_left le_sub_left_of_add_le
 
 @[to_additive]
 theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le_mul, mul_comm]
 #align div_le_iff_le_mul' div_le_iff_le_mul'
+#align sub_le_iff_le_add' sub_le_iff_le_add'
 
 alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
 
@@ -688,20 +759,24 @@ alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
 theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b :=
   le_div_iff_mul_le.trans inv_mul_le_iff_le_mul'
 #align inv_le_div_iff_le_mul inv_le_div_iff_le_mul
+#align neg_le_sub_iff_le_add neg_le_sub_iff_le_add
 
 @[to_additive]
 theorem inv_le_div_iff_le_mul' : a⁻¹ ≤ b / c ↔ c ≤ a * b := by rw [inv_le_div_iff_le_mul, mul_comm]
 #align inv_le_div_iff_le_mul' inv_le_div_iff_le_mul'
+#align neg_le_sub_iff_le_add' neg_le_sub_iff_le_add'
 
 @[to_additive]
 theorem div_le_comm : a / b ≤ c ↔ a / c ≤ b :=
   div_le_iff_le_mul'.trans div_le_iff_le_mul.symm
 #align div_le_comm div_le_comm
+#align sub_le_comm sub_le_comm
 
 @[to_additive]
 theorem le_div_comm : a ≤ b / c ↔ c ≤ b / a :=
   le_div_iff_mul_le'.trans le_div_iff_mul_le.symm
 #align le_div_comm le_div_comm
+#align le_sub_comm le_sub_comm
 
 end LE
 
@@ -714,6 +789,7 @@ theorem div_le_div'' (hab : a ≤ b) (hcd : c ≤ d) : a / d ≤ b / c := by
   rw [div_eq_mul_inv, div_eq_mul_inv, mul_comm b, mul_inv_le_inv_mul_iff, mul_comm]
   exact mul_le_mul' hab hcd
 #align div_le_div'' div_le_div''
+#align sub_le_sub sub_le_sub
 
 end Preorder
 
@@ -733,16 +809,19 @@ variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c d : α}
 theorem div_lt_div_iff_right (c : α) : a / c < b / c ↔ a < b := by
   simpa only [div_eq_mul_inv] using mul_lt_mul_iff_right _
 #align div_lt_div_iff_right div_lt_div_iff_right
+#align sub_lt_sub_iff_right sub_lt_sub_iff_right
 
 @[to_additive sub_lt_sub_right]
 theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c :=
   (div_lt_div_iff_right c).2 h
 #align div_lt_div_right' div_lt_div_right'
+#align sub_lt_sub_right sub_lt_sub_right
 
 @[to_additive (attr := simp) sub_pos]
 theorem one_lt_div' : 1 < a / b ↔ b < a := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_lt_div' one_lt_div'
+#align sub_pos sub_pos
 
 alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
 
@@ -750,6 +829,7 @@ alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
 theorem div_lt_one' : a / b < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_one' div_lt_one'
+#align sub_neg sub_neg
 
 alias sub_neg ↔ lt_of_sub_neg sub_neg_of_lt
 
@@ -759,6 +839,7 @@ alias sub_neg ← sub_lt_zero
 theorem lt_div_iff_mul_lt : a < c / b ↔ a * b < c := by
   rw [← mul_lt_mul_iff_right b, div_eq_mul_inv, inv_mul_cancel_right]
 #align lt_div_iff_mul_lt lt_div_iff_mul_lt
+#align lt_sub_iff_add_lt lt_sub_iff_add_lt
 
 alias lt_sub_iff_add_lt ↔ add_lt_of_lt_sub_right lt_sub_right_of_add_lt
 
@@ -766,6 +847,7 @@ alias lt_sub_iff_add_lt ↔ add_lt_of_lt_sub_right lt_sub_right_of_add_lt
 theorem div_lt_iff_lt_mul : a / c < b ↔ a < b * c := by
   rw [← mul_lt_mul_iff_right c, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_iff_lt_mul div_lt_iff_lt_mul
+#align sub_lt_iff_lt_add sub_lt_iff_lt_add
 
 alias sub_lt_iff_lt_add ↔ lt_add_of_sub_right_lt sub_right_lt_of_lt_add
 
@@ -781,16 +863,19 @@ theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_lt_mul_iff_left a⁻¹, inv_mul_cancel_left,
     inv_mul_cancel_left, inv_lt_inv_iff]
 #align div_lt_div_iff_left div_lt_div_iff_left
+#align sub_lt_sub_iff_left sub_lt_sub_iff_left
 
 @[to_additive (attr := simp)]
 theorem inv_lt_div_iff_lt_mul : a⁻¹ < b / c ↔ c < a * b := by
   rw [div_eq_mul_inv, lt_mul_inv_iff_mul_lt, inv_mul_lt_iff_lt_mul]
 #align inv_lt_div_iff_lt_mul inv_lt_div_iff_lt_mul
+#align neg_lt_sub_iff_lt_add neg_lt_sub_iff_lt_add
 
 @[to_additive sub_lt_sub_left]
 theorem div_lt_div_left' (h : a < b) (c : α) : c / b < c / a :=
   (div_lt_div_iff_left c).2 h
 #align div_lt_div_left' div_lt_div_left'
+#align sub_lt_sub_left sub_lt_sub_left
 
 end Left
 
@@ -808,16 +893,19 @@ variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c d : α}
 theorem div_lt_div_iff' : a / b < c / d ↔ a * d < c * b := by
   simpa only [div_eq_mul_inv] using mul_inv_lt_mul_inv_iff'
 #align div_lt_div_iff' div_lt_div_iff'
+#align sub_lt_sub_iff sub_lt_sub_iff
 
 @[to_additive]
 theorem lt_div_iff_mul_lt' : b < c / a ↔ a * b < c := by rw [lt_div_iff_mul_lt, mul_comm]
 #align lt_div_iff_mul_lt' lt_div_iff_mul_lt'
+#align lt_sub_iff_add_lt' lt_sub_iff_add_lt'
 
 alias lt_sub_iff_add_lt' ↔ add_lt_of_lt_sub_left lt_sub_left_of_add_lt
 
 @[to_additive]
 theorem div_lt_iff_lt_mul' : a / b < c ↔ a < b * c := by rw [div_lt_iff_lt_mul, mul_comm]
 #align div_lt_iff_lt_mul' div_lt_iff_lt_mul'
+#align sub_lt_iff_lt_add' sub_lt_iff_lt_add'
 
 alias sub_lt_iff_lt_add' ↔ lt_add_of_sub_left_lt sub_left_lt_of_lt_add
 
@@ -825,16 +913,19 @@ alias sub_lt_iff_lt_add' ↔ lt_add_of_sub_left_lt sub_left_lt_of_lt_add
 theorem inv_lt_div_iff_lt_mul' : b⁻¹ < a / c ↔ c < a * b :=
   lt_div_iff_mul_lt.trans inv_mul_lt_iff_lt_mul'
 #align inv_lt_div_iff_lt_mul' inv_lt_div_iff_lt_mul'
+#align neg_lt_sub_iff_lt_add' neg_lt_sub_iff_lt_add'
 
 @[to_additive]
 theorem div_lt_comm : a / b < c ↔ a / c < b :=
   div_lt_iff_lt_mul'.trans div_lt_iff_lt_mul.symm
 #align div_lt_comm div_lt_comm
+#align sub_lt_comm sub_lt_comm
 
 @[to_additive]
 theorem lt_div_comm : a < b / c ↔ c < b / a :=
   lt_div_iff_mul_lt'.trans lt_div_iff_mul_lt.symm
 #align lt_div_comm lt_div_comm
+#align lt_sub_comm lt_sub_comm
 
 end LT
 
@@ -847,6 +938,7 @@ theorem div_lt_div'' (hab : a < b) (hcd : c < d) : a / d < b / c := by
   rw [div_eq_mul_inv, div_eq_mul_inv, mul_comm b, mul_inv_lt_inv_mul_iff, mul_comm]
   exact mul_lt_mul_of_lt_of_lt hab hcd
 #align div_lt_div'' div_lt_div''
+#align sub_lt_sub sub_lt_sub
 
 end Preorder
 
@@ -860,6 +952,7 @@ variable [Group α] [LinearOrder α]
 theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
     cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel']
 #align cmp_div_one' cmp_div_one'
+#align cmp_sub_zero cmp_sub_zero
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
@@ -871,11 +964,13 @@ variable {a b c : α}
 theorem le_of_forall_one_lt_lt_mul (h : ∀ ε : α, 1 < ε → a < b * ε) : a ≤ b :=
   le_of_not_lt fun h₁ => lt_irrefl a (by simpa using h _ (lt_inv_mul_iff_lt.mpr h₁))
 #align le_of_forall_one_lt_lt_mul le_of_forall_one_lt_lt_mul
+#align le_of_forall_pos_lt_add le_of_forall_pos_lt_add
 
 @[to_additive]
 theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε :=
   ⟨fun h _ => lt_mul_of_le_of_one_lt h, le_of_forall_one_lt_lt_mul⟩
 #align le_iff_forall_one_lt_lt_mul le_iff_forall_one_lt_lt_mul
+#align le_iff_forall_pos_lt_add le_iff_forall_pos_lt_add
 
 /-  I (DT) introduced this lemma to prove (the additive version `sub_le_sub_flip` of)
 `div_le_div_flip` below.  Now I wonder what is the point of either of these lemmas... -/
@@ -887,6 +982,7 @@ theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
     ⟨fun h => not_lt.mp fun k => not_lt.mpr h (mul_lt_mul_of_lt_of_lt k k), fun h =>
       mul_le_mul' h h⟩
 #align div_le_inv_mul_iff div_le_inv_mul_iff
+#align sub_le_neg_add_iff sub_le_neg_add_iff
 
 -- What is the point of this lemma?  See comment about `div_le_inv_mul_iff` above.
 -- Note: we intentionally don't have `@[simp]` for the additive version,
@@ -897,6 +993,7 @@ theorem div_le_div_flip {α : Type _} [CommGroup α] [LinearOrder α]
   rw [div_eq_mul_inv b, mul_comm]
   exact div_le_inv_mul_iff
 #align div_le_div_flip div_le_div_flip
+#align sub_le_sub_flip sub_le_sub_flip
 
 end VariableNames
 
@@ -936,6 +1033,7 @@ variable [LinearOrderedCommGroup α] {a b c : α}
 theorem LinearOrderedCommGroup.mul_lt_mul_left' (a b : α) (h : a < b) (c : α) : c * a < c * b :=
   _root_.mul_lt_mul_left' h c
 #align linear_ordered_comm_group.mul_lt_mul_left' LinearOrderedCommGroup.mul_lt_mul_left'
+#align linear_ordered_add_comm_group.add_lt_add_left LinearOrderedAddCommGroup.add_lt_add_left
 
 @[to_additive eq_zero_of_neg_eq]
 theorem eq_one_of_inv_eq' (h : a⁻¹ = a) : a = 1 :=
@@ -948,6 +1046,7 @@ theorem eq_one_of_inv_eq' (h : a⁻¹ = a) : a = 1 :=
     have : a < 1 := h ▸ inv_lt_one'.mpr h₁
     absurd h₁ this.asymm
 #align eq_one_of_inv_eq' eq_one_of_inv_eq'
+#align eq_zero_of_neg_eq eq_zero_of_neg_eq
 
 @[to_additive exists_zero_lt]
 theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a := by
@@ -956,6 +1055,7 @@ theorem exists_one_lt' [Nontrivial α] : ∃ a : α, 1 < a := by
   · exact ⟨y⁻¹, one_lt_inv'.mpr h⟩
   · exact ⟨y, h⟩
 #align exists_one_lt' exists_one_lt'
+#align exists_zero_lt exists_zero_lt
 
 -- see Note [lower instance priority]
 @[to_additive]
@@ -964,6 +1064,7 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMaxOrder [Nontrivial α]
     obtain ⟨y, hy⟩ : ∃ a : α, 1 < a := exists_one_lt'
     exact fun a => ⟨a * y, lt_mul_of_one_lt_right' a hy⟩⟩
 #align linear_ordered_comm_group.to_no_max_order LinearOrderedCommGroup.to_noMaxOrder
+#align linear_ordered_add_comm_group.to_no_max_order LinearOrderedAddCommGroup.to_noMaxOrder
 
 -- see Note [lower instance priority]
 @[to_additive]
@@ -972,6 +1073,7 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMinOrder [Nontrivial α]
     obtain ⟨y, hy⟩ : ∃ a : α, 1 < a := exists_one_lt'
     exact fun a => ⟨a / y, (div_lt_self_iff a).mpr hy⟩⟩
 #align linear_ordered_comm_group.to_no_min_order LinearOrderedCommGroup.to_noMinOrder
+#align linear_ordered_add_comm_group.to_no_min_order LinearOrderedAddCommGroup.to_noMinOrder
 
 -- See note [lower instance priority]
 @[to_additive]
@@ -1061,29 +1163,34 @@ theorem inv_le_inv' : a ≤ b → b⁻¹ ≤ a⁻¹ :=
   -- Porting note: explicit type annotation was not needed before.
   (@inv_le_inv_iff α ..).mpr
 #align inv_le_inv' inv_le_inv'
+#align neg_le_neg neg_le_neg
 
 @[to_additive neg_lt_neg]
 theorem inv_lt_inv' : a < b → b⁻¹ < a⁻¹ :=
   -- Porting note: explicit type annotation was not needed before.
   (@inv_lt_inv_iff α ..).mpr
 #align inv_lt_inv' inv_lt_inv'
+#align neg_lt_neg neg_lt_neg
 
 --  The additive version is also a `linarith` lemma.
 @[to_additive]
 theorem inv_lt_one_of_one_lt : 1 < a → a⁻¹ < 1 :=
   inv_lt_one_iff_one_lt.mpr
 #align inv_lt_one_of_one_lt inv_lt_one_of_one_lt
+#align neg_neg_of_pos neg_neg_of_pos
 
 --  The additive version is also a `linarith` lemma.
 @[to_additive]
 theorem inv_le_one_of_one_le : 1 ≤ a → a⁻¹ ≤ 1 :=
   inv_le_one'.mpr
 #align inv_le_one_of_one_le inv_le_one_of_one_le
+#align neg_nonpos_of_nonneg neg_nonpos_of_nonneg
 
 @[to_additive neg_nonneg_of_nonpos]
 theorem one_le_inv_of_le_one : a ≤ 1 → 1 ≤ a⁻¹ :=
   one_le_inv'.mpr
 #align one_le_inv_of_le_one one_le_inv_of_le_one
+#align neg_nonneg_of_nonpos neg_nonneg_of_nonpos
 
 end NormNumLemmas
 
@@ -1096,21 +1203,25 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 theorem Monotone.inv (hf : Monotone f) : Antitone fun x => (f x)⁻¹ := fun _ _ hxy =>
   inv_le_inv_iff.2 (hf hxy)
 #align monotone.inv Monotone.inv
+#align monotone.neg Monotone.neg
 
 @[to_additive]
 theorem Antitone.inv (hf : Antitone f) : Monotone fun x => (f x)⁻¹ := fun _ _ hxy =>
   inv_le_inv_iff.2 (hf hxy)
 #align antitone.inv Antitone.inv
+#align antitone.neg Antitone.neg
 
 @[to_additive]
 theorem MonotoneOn.inv (hf : MonotoneOn f s) : AntitoneOn (fun x => (f x)⁻¹) s :=
   fun _ hx _ hy hxy => inv_le_inv_iff.2 (hf hx hy hxy)
 #align monotone_on.inv MonotoneOn.inv
+#align monotone_on.neg MonotoneOn.neg
 
 @[to_additive]
 theorem AntitoneOn.inv (hf : AntitoneOn f s) : MonotoneOn (fun x => (f x)⁻¹) s :=
   fun _ hx _ hy hxy => inv_le_inv_iff.2 (hf hx hy hxy)
 #align antitone_on.inv AntitoneOn.inv
+#align antitone_on.neg AntitoneOn.neg
 
 end
 
@@ -1123,20 +1234,24 @@ variable {β : Type _} [Group α] [Preorder α] [CovariantClass α α (· * ·)
 theorem StrictMono.inv (hf : StrictMono f) : StrictAnti fun x => (f x)⁻¹ := fun _ _ hxy =>
   inv_lt_inv_iff.2 (hf hxy)
 #align strict_mono.inv StrictMono.inv
+#align strict_mono.neg StrictMono.neg
 
 @[to_additive]
 theorem StrictAnti.inv (hf : StrictAnti f) : StrictMono fun x => (f x)⁻¹ := fun _ _ hxy =>
   inv_lt_inv_iff.2 (hf hxy)
 #align strict_anti.inv StrictAnti.inv
+#align strict_anti.neg StrictAnti.neg
 
 @[to_additive]
 theorem StrictMonoOn.inv (hf : StrictMonoOn f s) : StrictAntiOn (fun x => (f x)⁻¹) s :=
   fun _ hx _ hy hxy => inv_lt_inv_iff.2 (hf hx hy hxy)
 #align strict_mono_on.inv StrictMonoOn.inv
+#align strict_mono_on.neg StrictMonoOn.neg
 
 @[to_additive]
 theorem StrictAntiOn.inv (hf : StrictAntiOn f s) : StrictMonoOn (fun x => (f x)⁻¹) s :=
   fun _ hx _ hy hxy => inv_lt_inv_iff.2 (hf hx hy hxy)
 #align strict_anti_on.inv StrictAntiOn.inv
+#align strict_anti_on.neg StrictAntiOn.neg
 
 end

chore: format by line breaks with long lines (#1529)

This was done semi-automatically with some regular expressions in vim in contrast to the fully automatic https://github.com/leanprover-community/mathlib4/pull/1523.

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

1050066f

Diff

@@ -880,8 +880,8 @@ theorem le_iff_forall_one_lt_lt_mul : a ≤ b ↔ ∀ ε, 1 < ε → a < b * ε
 /-  I (DT) introduced this lemma to prove (the additive version `sub_le_sub_flip` of)
 `div_le_div_flip` below.  Now I wonder what is the point of either of these lemmas... -/
 @[to_additive]
-theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] : a / b ≤ a⁻¹ * b ↔ a ≤ b :=
-  by
+theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
+    a / b ≤ a⁻¹ * b ↔ a ≤ b := by
   rw [div_eq_mul_inv, mul_inv_le_inv_mul_iff]
   exact
     ⟨fun h => not_lt.mp fun k => not_lt.mpr h (mul_lt_mul_of_lt_of_lt k k), fun h =>

chore: the style linter shouldn't complain about long #align lines (#1643)

54af0498

Diff

@@ -59,8 +59,7 @@ instance (priority := 100) OrderedCommGroup.toOrderedCancelCommMonoid [OrderedCo
     OrderedCancelCommMonoid α :=
 { ‹OrderedCommGroup α› with le_of_mul_le_mul_left := fun a b c ↦ le_of_mul_le_mul_left' }
 #align ordered_comm_group.to_ordered_cancel_comm_monoid OrderedCommGroup.toOrderedCancelCommMonoid
-#align ordered_add_comm_group.to_ordered_cancel_add_comm_monoid
-  OrderedAddCommGroup.toOrderedCancelAddCommMonoid
+#align ordered_add_comm_group.to_ordered_cancel_add_comm_monoid OrderedAddCommGroup.toOrderedCancelAddCommMonoid
 
 example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (· + ·)) (· < ·) :=
   AddRightCancelSemigroup.covariant_swap_add_lt_of_covariant_swap_add_le α
@@ -70,16 +69,14 @@ example (α : Type u) [OrderedAddCommGroup α] : CovariantClass α α (swap (·
 instance OrderedCommGroup.to_contravariantClass_left_le (α : Type u) [OrderedCommGroup α] :
     ContravariantClass α α (· * ·)
       (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_left' bc a⁻¹
-#align
-  ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
+#align ordered_comm_group.to_contravariant_class_left_le OrderedCommGroup.to_contravariantClass_left_le
 
 /-- A choice-free shortcut instance. -/
 @[to_additive "A choice-free shortcut instance."]
 instance OrderedCommGroup.to_contravariantClass_right_le (α : Type u) [OrderedCommGroup α] :
     ContravariantClass α α (swap (· * ·))
       (· ≤ ·) where elim a b c bc := by simpa using mul_le_mul_right' bc a⁻¹
-#align
-  ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_le
+#align ordered_comm_group.to_contravariant_class_right_le OrderedCommGroup.to_contravariantClass_right_le
 
 section Group
 
@@ -981,10 +978,8 @@ instance (priority := 100) LinearOrderedCommGroup.to_noMinOrder [Nontrivial α]
 instance (priority := 100) LinearOrderedCommGroup.toLinearOrderedCancelCommMonoid
     [LinearOrderedCommGroup α] : LinearOrderedCancelCommMonoid α :=
 { ‹LinearOrderedCommGroup α›, OrderedCommGroup.toOrderedCancelCommMonoid with }
-#align linear_ordered_comm_group.to_linear_ordered_cancel_comm_monoid
-  LinearOrderedCommGroup.toLinearOrderedCancelCommMonoid
-#align linear_ordered_add_comm_group.to_linear_ordered_cancel_add_comm_monoid
-  LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid
+#align linear_ordered_comm_group.to_linear_ordered_cancel_comm_monoid LinearOrderedCommGroup.toLinearOrderedCancelCommMonoid
+#align linear_ordered_add_comm_group.to_linear_ordered_cancel_add_comm_monoid LinearOrderedAddCommGroup.toLinearOrderedAddCancelCommMonoid
 
 end LinearOrderedCommGroup

feat: improve the way to_additive deals with attributes (#1314)

The new syntax for any attributes that need to be copied by to_additive is @[to_additive (attrs := simp, ext, simps)]
Adds the auxiliary declarations generated by the simp and simps attributes to the to_additive-dictionary.
Future issue: Does not yet translate auxiliary declarations for other attributes (including custom simp-attributes). In particular it's possible that norm_cast might generate some auxiliary declarations.
Fixes #950
Fixes #953
Fixes #1149
This moves the interaction between to_additive and simps from the Simps file to the toAdditive file for uniformity.
Make the same changes to @[reassoc]

Co-authored-by: Johan Commelin <johan@commelin.net> Co-authored-by: Scott Morrison <scott.morrison@gmail.com>

56bf4cd6

Diff

@@ -90,26 +90,26 @@ section TypeclassesLeftLE
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] {a b c d : α}
 
 /-- Uses `left` co(ntra)variant. -/
-@[simp, to_additive "Uses `left` co(ntra)variant."]
+@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
 theorem Left.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by
   rw [← mul_le_mul_iff_left a]
   simp
 #align left.inv_le_one_iff Left.inv_le_one_iff
 
 /-- Uses `left` co(ntra)variant. -/
-@[simp, to_additive "Uses `left` co(ntra)variant."]
+@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
 theorem Left.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by
   rw [← mul_le_mul_iff_left a]
   simp
 #align left.one_le_inv_iff Left.one_le_inv_iff
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem le_inv_mul_iff_mul_le : b ≤ a⁻¹ * c ↔ a * b ≤ c := by
   rw [← mul_le_mul_iff_left a]
   simp
 #align le_inv_mul_iff_mul_le le_inv_mul_iff_mul_le
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_mul_le_iff_le_mul : b⁻¹ * a ≤ c ↔ a ≤ b * c := by
   rw [← mul_le_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_le_iff_le_mul inv_mul_le_iff_le_mul
@@ -142,24 +142,24 @@ section TypeclassesLeftLT
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] {a b c : α}
 
 /-- Uses `left` co(ntra)variant. -/
-@[simp, to_additive Left.neg_pos_iff "Uses `left` co(ntra)variant."]
+@[to_additive (attr := simp) Left.neg_pos_iff "Uses `left` co(ntra)variant."]
 theorem Left.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
   rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
 #align left.one_lt_inv_iff Left.one_lt_inv_iff
 
 /-- Uses `left` co(ntra)variant. -/
-@[simp, to_additive "Uses `left` co(ntra)variant."]
+@[to_additive (attr := simp) "Uses `left` co(ntra)variant."]
 theorem Left.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
   rw [← mul_lt_mul_iff_left a, mul_inv_self, mul_one]
 #align left.inv_lt_one_iff Left.inv_lt_one_iff
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem lt_inv_mul_iff_mul_lt : b < a⁻¹ * c ↔ a * b < c := by
   rw [← mul_lt_mul_iff_left a]
   simp
 #align lt_inv_mul_iff_mul_lt lt_inv_mul_iff_mul_lt
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_mul_lt_iff_lt_mul : b⁻¹ * a < c ↔ a < b * c := by
   rw [← mul_lt_mul_iff_left b, mul_inv_cancel_left]
 #align inv_mul_lt_iff_lt_mul inv_mul_lt_iff_lt_mul
@@ -191,14 +191,14 @@ section TypeclassesRightLE
 variable [LE α] [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
 /-- Uses `right` co(ntra)variant. -/
-@[simp, to_additive "Uses `right` co(ntra)variant."]
+@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
 theorem Right.inv_le_one_iff : a⁻¹ ≤ 1 ↔ 1 ≤ a := by
   rw [← mul_le_mul_iff_right a]
   simp
 #align right.inv_le_one_iff Right.inv_le_one_iff
 
 /-- Uses `right` co(ntra)variant. -/
-@[simp, to_additive "Uses `right` co(ntra)variant."]
+@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
 theorem Right.one_le_inv_iff : 1 ≤ a⁻¹ ↔ a ≤ 1 := by
   rw [← mul_le_mul_iff_right a]
   simp
@@ -214,12 +214,12 @@ theorem le_inv_iff_mul_le_one_right : a ≤ b⁻¹ ↔ a * b ≤ 1 :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align le_inv_iff_mul_le_one_right le_inv_iff_mul_le_one_right
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_inv_le_iff_le_mul : a * b⁻¹ ≤ c ↔ a ≤ c * b :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align mul_inv_le_iff_le_mul mul_inv_le_iff_le_mul
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem le_mul_inv_iff_mul_le : c ≤ a * b⁻¹ ↔ c * b ≤ a :=
   (mul_le_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align le_mul_inv_iff_mul_le le_mul_inv_iff_mul_le
@@ -247,13 +247,13 @@ section TypeclassesRightLT
 variable [LT α] [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c : α}
 
 /-- Uses `right` co(ntra)variant. -/
-@[simp, to_additive "Uses `right` co(ntra)variant."]
+@[to_additive (attr := simp) "Uses `right` co(ntra)variant."]
 theorem Right.inv_lt_one_iff : a⁻¹ < 1 ↔ 1 < a := by
   rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
 #align right.inv_lt_one_iff Right.inv_lt_one_iff
 
 /-- Uses `right` co(ntra)variant. -/
-@[simp, to_additive Right.neg_pos_iff "Uses `right` co(ntra)variant."]
+@[to_additive (attr := simp) Right.neg_pos_iff "Uses `right` co(ntra)variant."]
 theorem Right.one_lt_inv_iff : 1 < a⁻¹ ↔ a < 1 := by
   rw [← mul_lt_mul_iff_right a, inv_mul_self, one_mul]
 #align right.one_lt_inv_iff Right.one_lt_inv_iff
@@ -268,12 +268,12 @@ theorem lt_inv_iff_mul_lt_one : a < b⁻¹ ↔ a * b < 1 :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_self]
 #align lt_inv_iff_mul_lt_one lt_inv_iff_mul_lt_one
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem mul_inv_lt_iff_lt_mul : a * b⁻¹ < c ↔ a < c * b := by
   rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right]
 #align mul_inv_lt_iff_lt_mul mul_inv_lt_iff_lt_mul
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem lt_mul_inv_iff_mul_lt : c < a * b⁻¹ ↔ c * b < a :=
   (mul_lt_mul_iff_right b).symm.trans <| by rw [inv_mul_cancel_right]
 #align lt_mul_inv_iff_mul_lt lt_mul_inv_iff_mul_lt
@@ -301,7 +301,7 @@ section TypeclassesLeftRightLE
 variable [LE α] [CovariantClass α α (· * ·) (· ≤ ·)] [CovariantClass α α (swap (· * ·)) (· ≤ ·)]
   {a b c d : α}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_le_inv_iff : a⁻¹ ≤ b⁻¹ ↔ b ≤ a := by
   rw [← mul_le_mul_iff_left a, ← mul_le_mul_iff_right b]
   simp
@@ -315,13 +315,13 @@ theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b :
     inv_mul_cancel_right]
 #align mul_inv_le_inv_mul_iff mul_inv_le_inv_mul_iff
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b := by
   -- Porting note: was `simp [div_eq_mul_inv]`
   simp only [div_eq_mul_inv, mul_le_iff_le_one_right', Left.inv_le_one_iff]
 #align div_le_self_iff div_le_self_iff
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by
   -- Porting note: was `simp [div_eq_mul_inv]`
   simp only [div_eq_mul_inv, le_mul_iff_one_le_right', Left.one_le_inv_iff]
@@ -336,7 +336,7 @@ section TypeclassesLeftRightLT
 variable [LT α] [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (swap (· * ·)) (· < ·)]
   {a b c d : α}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_lt_inv_iff : a⁻¹ < b⁻¹ ↔ b < a := by
   rw [← mul_lt_mul_iff_left a, ← mul_lt_mul_iff_right b]
   simp
@@ -364,7 +364,7 @@ theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
     inv_mul_cancel_right]
 #align mul_inv_lt_inv_mul_iff mul_inv_lt_inv_mul_iff
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by
   -- Porting note: was `simp [div_eq_mul_inv]`
   simp only [div_eq_mul_inv, mul_lt_iff_lt_one_left', Left.inv_lt_one_iff]
@@ -595,7 +595,7 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c d : α}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem div_le_div_iff_right (c : α) : a / c ≤ b / c ↔ a ≤ b := by
   simpa only [div_eq_mul_inv] using mul_le_mul_iff_right _
 #align div_le_div_iff_right div_le_div_iff_right
@@ -605,14 +605,14 @@ theorem div_le_div_right' (h : a ≤ b) (c : α) : a / c ≤ b / c :=
   (div_le_div_iff_right c).2 h
 #align div_le_div_right' div_le_div_right'
 
-@[simp, to_additive sub_nonneg]
+@[to_additive (attr := simp) sub_nonneg]
 theorem one_le_div' : 1 ≤ a / b ↔ b ≤ a := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_le_div' one_le_div'
 
 alias sub_nonneg ↔ le_of_sub_nonneg sub_nonneg_of_le
 
-@[simp, to_additive sub_nonpos]
+@[to_additive (attr := simp) sub_nonpos]
 theorem div_le_one' : a / b ≤ 1 ↔ a ≤ b := by
   rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_le_one' div_le_one'
@@ -647,7 +647,7 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
 variable [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a b c : α}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem div_le_div_iff_left (a : α) : a / b ≤ a / c ↔ c ≤ b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_le_mul_iff_left a⁻¹, inv_mul_cancel_left,
     inv_mul_cancel_left, inv_le_inv_iff]
@@ -687,7 +687,7 @@ theorem div_le_iff_le_mul' : a / b ≤ c ↔ a ≤ b * c := by rw [div_le_iff_le
 
 alias sub_le_iff_le_add' ↔ le_add_of_sub_left_le sub_left_le_of_le_add
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_le_div_iff_le_mul : b⁻¹ ≤ a / c ↔ c ≤ a * b :=
   le_div_iff_mul_le.trans inv_mul_le_iff_le_mul'
 #align inv_le_div_iff_le_mul inv_le_div_iff_le_mul
@@ -732,7 +732,7 @@ section Right
 
 variable [CovariantClass α α (swap (· * ·)) (· < ·)] {a b c d : α}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem div_lt_div_iff_right (c : α) : a / c < b / c ↔ a < b := by
   simpa only [div_eq_mul_inv] using mul_lt_mul_iff_right _
 #align div_lt_div_iff_right div_lt_div_iff_right
@@ -742,14 +742,14 @@ theorem div_lt_div_right' (h : a < b) (c : α) : a / c < b / c :=
   (div_lt_div_iff_right c).2 h
 #align div_lt_div_right' div_lt_div_right'
 
-@[simp, to_additive sub_pos]
+@[to_additive (attr := simp) sub_pos]
 theorem one_lt_div' : 1 < a / b ↔ b < a := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align one_lt_div' one_lt_div'
 
 alias sub_pos ↔ lt_of_sub_pos sub_pos_of_lt
 
-@[simp, to_additive sub_neg]
+@[to_additive (attr := simp) sub_neg]
 theorem div_lt_one' : a / b < 1 ↔ a < b := by
   rw [← mul_lt_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
 #align div_lt_one' div_lt_one'
@@ -779,13 +779,13 @@ section Left
 variable [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (swap (· * ·)) (· < ·)]
   {a b c : α}
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem div_lt_div_iff_left (a : α) : a / b < a / c ↔ c < b := by
   rw [div_eq_mul_inv, div_eq_mul_inv, ← mul_lt_mul_iff_left a⁻¹, inv_mul_cancel_left,
     inv_mul_cancel_left, inv_lt_inv_iff]
 #align div_lt_div_iff_left div_lt_div_iff_left
 
-@[simp, to_additive]
+@[to_additive (attr := simp)]
 theorem inv_lt_div_iff_lt_mul : a⁻¹ < b / c ↔ c < a * b := by
   rw [div_eq_mul_inv, lt_mul_inv_iff_mul_lt, inv_mul_lt_iff_lt_mul]
 #align inv_lt_div_iff_lt_mul inv_lt_div_iff_lt_mul
@@ -859,7 +859,7 @@ section LinearOrder
 
 variable [Group α] [LinearOrder α]
 
-@[simp, to_additive cmp_sub_zero]
+@[to_additive (attr := simp) cmp_sub_zero]
 theorem cmp_div_one' [CovariantClass α α (swap (· * ·)) (· ≤ ·)] (a b : α) :
     cmp (a / b) 1 = cmp a b := by rw [← cmp_mul_right' _ _ b, one_mul, div_mul_cancel']
 #align cmp_div_one' cmp_div_one'
@@ -891,7 +891,9 @@ theorem div_le_inv_mul_iff [CovariantClass α α (swap (· * ·)) (· ≤ ·)] :
       mul_le_mul' h h⟩
 #align div_le_inv_mul_iff div_le_inv_mul_iff
 
---  What is the point of this lemma?  See comment about `div_le_inv_mul_iff` above.
+-- What is the point of this lemma?  See comment about `div_le_inv_mul_iff` above.
+-- Note: we intentionally don't have `@[simp]` for the additive version,
+-- since the LHS simplifies with `tsub_le_iff_right`
 @[to_additive, simp]
 theorem div_le_div_flip {α : Type _} [CommGroup α] [LinearOrder α]
     [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} : a / b ≤ b / a ↔ a ≤ b := by

chore: remove iff_self from simp only after lean4#1933 (#1406)

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

72b23bd4

Diff

@@ -318,13 +318,13 @@ theorem mul_inv_le_inv_mul_iff : a * b⁻¹ ≤ d⁻¹ * c ↔ d * a ≤ c * b :
 @[simp, to_additive]
 theorem div_le_self_iff (a : α) {b : α} : a / b ≤ a ↔ 1 ≤ b := by
   -- Porting note: was `simp [div_eq_mul_inv]`
-  simp only [div_eq_mul_inv, mul_le_iff_le_one_right', Left.inv_le_one_iff, iff_self]
+  simp only [div_eq_mul_inv, mul_le_iff_le_one_right', Left.inv_le_one_iff]
 #align div_le_self_iff div_le_self_iff
 
 @[simp, to_additive]
 theorem le_div_self_iff (a : α) {b : α} : a ≤ a / b ↔ b ≤ 1 := by
   -- Porting note: was `simp [div_eq_mul_inv]`
-  simp only [div_eq_mul_inv, le_mul_iff_one_le_right', Left.one_le_inv_iff, iff_self]
+  simp only [div_eq_mul_inv, le_mul_iff_one_le_right', Left.one_le_inv_iff]
 #align le_div_self_iff le_div_self_iff
 
 alias sub_le_self_iff ↔ _ sub_le_self
@@ -367,7 +367,7 @@ theorem mul_inv_lt_inv_mul_iff : a * b⁻¹ < d⁻¹ * c ↔ d * a < c * b := by
 @[simp, to_additive]
 theorem div_lt_self_iff (a : α) {b : α} : a / b < a ↔ 1 < b := by
   -- Porting note: was `simp [div_eq_mul_inv]`
-  simp only [div_eq_mul_inv, mul_lt_iff_lt_one_left', Left.inv_lt_one_iff, iff_self]
+  simp only [div_eq_mul_inv, mul_lt_iff_lt_one_left', Left.inv_lt_one_iff]
 #align div_lt_self_iff div_lt_self_iff
 
 alias sub_lt_self_iff ↔ _ sub_lt_self