algebra.order.ring.lemmas | Mathlib porting status

Changes since the initial port

The following section lists changes to this file in mathlib3 and mathlib4 that occured after the initial port. Most recent changes are shown first. Hovering over a commit will show all commits associated with the same mathlib3 commit.

Changes in mathlib3

44e29dbc

(last sync)

feat(algebra/order/ring/defs): negative versions of order lemmas (#18831)

For each of a handful of lemmas with a 0 < or 0 ≤ assumption, this adds a variant with a < 0 or ≤ 0 assumption.

Diff

@@ -548,7 +548,10 @@ lemma mul_lt_iff_lt_one_left
   a * b < b ↔ a < 1 :=
 iff.trans (by rw [one_mul]) (mul_lt_mul_right b0)
 
-/-! Lemmas of the form `1 ≤ b → a ≤ a * b`. -/
+/-! Lemmas of the form `1 ≤ b → a ≤ a * b`.
+
+Variants with `< 0` and `≤ 0` instead of `0 <` and `0 ≤` appear in `algebra/order/ring/defs` (which
+imports this file) as they need additional results which are not yet available here. -/
 
 lemma mul_le_of_le_one_left [mul_pos_mono α] (hb : 0 ≤ b) (h : a ≤ 1) : a * b ≤ b :=
 by simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb

c4658a64

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

44e29dbc

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -702,7 +702,7 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
   rcases lt_trichotomy 0 a with (ha | rfl | ha)
   · refine' Or.inl ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonneg_of_nonpos ha.le hb
-  · rw [MulZeroClass.zero_mul] at hab ; exact hab.false.elim
+  · rw [MulZeroClass.zero_mul] at hab; exact hab.false.elim
   · refine' Or.inr ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonpos_of_nonneg ha.le hb
 #align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_pos

44e29dbc

bump to nightly-2023-12-28-06

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

c30f5587

Diff

@@ -436,11 +436,11 @@ theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) :
 #align mul_neg_of_pos_of_neg mul_neg_of_pos_of_neg
 -/
 
-#print zero_lt_mul_left /-
+#print mul_pos_iff_of_pos_left /-
 @[simp]
-theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) : 0 < c * b ↔ 0 < b :=
-  by convert mul_lt_mul_left h; simp
-#align zero_lt_mul_left zero_lt_mul_left
+theorem mul_pos_iff_of_pos_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) :
+    0 < c * b ↔ 0 < b := by convert mul_lt_mul_left h; simp
+#align zero_lt_mul_left mul_pos_iff_of_pos_left
 -/
 
 #print Right.mul_pos /-
@@ -456,11 +456,11 @@ theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) :
 #align mul_neg_of_neg_of_pos mul_neg_of_neg_of_pos
 -/
 
-#print zero_lt_mul_right /-
+#print mul_pos_iff_of_pos_right /-
 @[simp]
-theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
+theorem mul_pos_iff_of_pos_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
     0 < b * c ↔ 0 < b := by convert mul_lt_mul_right h; simp
-#align zero_lt_mul_right zero_lt_mul_right
+#align zero_lt_mul_right mul_pos_iff_of_pos_right
 -/
 
 #print Left.mul_nonneg /-

44e29dbc

bump to nightly-2023-12-10-06

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

5eef91c6

Diff

@@ -114,20 +114,20 @@ abbrev MulPosReflectLT : Prop :=
 #align mul_pos_reflect_lt MulPosReflectLT
 -/
 
-#print PosMulMonoRev /-
+#print PosMulReflectLE /-
 /-- `pos_mul_mono_rev α` is an abbreviation for `contravariant_class α>0 α (λ x y, x * y) (≤)`,
 expressing that multiplication by positive elements on the left is reverse monotone. -/
-abbrev PosMulMonoRev : Prop :=
+abbrev PosMulReflectLE : Prop :=
   ContravariantClass α>0 α (fun x y => x * y) (· ≤ ·)
-#align pos_mul_mono_rev PosMulMonoRev
+#align pos_mul_mono_rev PosMulReflectLE
 -/
 
-#print MulPosMonoRev /-
+#print MulPosReflectLE /-
 /-- `mul_pos_mono_rev α` is an abbreviation for `contravariant_class α>0 α (λ x y, y * x) (≤)`,
 expressing that multiplication by positive elements on the right is reverse monotone. -/
-abbrev MulPosMonoRev : Prop :=
+abbrev MulPosReflectLE : Prop :=
   ContravariantClass α>0 α (fun x y => y * x) (· ≤ ·)
-#align mul_pos_mono_rev MulPosMonoRev
+#align mul_pos_mono_rev MulPosReflectLE
 -/
 
 end Abbreviations
@@ -207,13 +207,13 @@ theorem lt_of_mul_lt_mul_right [MulPosReflectLT α] (h : b * a < c * a) (a0 : 0
 -/
 
 #print le_of_mul_le_mul_left /-
-theorem le_of_mul_le_mul_left [PosMulMonoRev α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
+theorem le_of_mul_le_mul_left [PosMulReflectLE α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_left le_of_mul_le_mul_left
 -/
 
 #print le_of_mul_le_mul_right /-
-theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
+theorem le_of_mul_le_mul_right [MulPosReflectLE α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_right le_of_mul_le_mul_right
 -/
@@ -248,14 +248,14 @@ theorem mul_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a)
 
 #print mul_le_mul_left /-
 @[simp]
-theorem mul_le_mul_left [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
+theorem mul_le_mul_left [PosMulMono α] [PosMulReflectLE α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_left mul_le_mul_left
 -/
 
 #print mul_le_mul_right /-
 @[simp]
-theorem mul_le_mul_right [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
+theorem mul_le_mul_right [MulPosMono α] [MulPosReflectLE α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_right mul_le_mul_right
 -/
@@ -337,39 +337,39 @@ section LinearOrder
 variable [LinearOrder α]
 
 -- see Note [lower instance priority]
-instance (priority := 100) PosMulStrictMono.to_posMulMonoRev [PosMulStrictMono α] :
-    PosMulMonoRev α :=
+instance (priority := 100) PosMulStrictMono.to_posMulReflectLE [PosMulStrictMono α] :
+    PosMulReflectLE α :=
   ⟨fun x a b h => le_of_not_lt fun h' => h.not_lt <| mul_lt_mul_of_pos_left h' x.Prop⟩
-#align pos_mul_strict_mono.to_pos_mul_mono_rev PosMulStrictMono.to_posMulMonoRev
+#align pos_mul_strict_mono.to_pos_mul_mono_rev PosMulStrictMono.to_posMulReflectLE
 
 -- see Note [lower instance priority]
-instance (priority := 100) MulPosStrictMono.to_mulPosMonoRev [MulPosStrictMono α] :
-    MulPosMonoRev α :=
+instance (priority := 100) MulPosStrictMono.to_mulPosReflectLE [MulPosStrictMono α] :
+    MulPosReflectLE α :=
   ⟨fun x a b h => le_of_not_lt fun h' => h.not_lt <| mul_lt_mul_of_pos_right h' x.Prop⟩
-#align mul_pos_strict_mono.to_mul_pos_mono_rev MulPosStrictMono.to_mulPosMonoRev
+#align mul_pos_strict_mono.to_mul_pos_mono_rev MulPosStrictMono.to_mulPosReflectLE
 
-#print PosMulMonoRev.toPosMulStrictMono /-
-theorem PosMulMonoRev.toPosMulStrictMono [PosMulMonoRev α] : PosMulStrictMono α :=
+#print PosMulReflectLE.toPosMulStrictMono /-
+theorem PosMulReflectLE.toPosMulStrictMono [PosMulReflectLE α] : PosMulStrictMono α :=
   ⟨fun x a b h => lt_of_not_le fun h' => h.not_le <| le_of_mul_le_mul_of_pos_left h' x.Prop⟩
-#align pos_mul_mono_rev.to_pos_mul_strict_mono PosMulMonoRev.toPosMulStrictMono
+#align pos_mul_mono_rev.to_pos_mul_strict_mono PosMulReflectLE.toPosMulStrictMono
 -/
 
-#print MulPosMonoRev.toMulPosStrictMono /-
-theorem MulPosMonoRev.toMulPosStrictMono [MulPosMonoRev α] : MulPosStrictMono α :=
+#print MulPosReflectLE.toMulPosStrictMono /-
+theorem MulPosReflectLE.toMulPosStrictMono [MulPosReflectLE α] : MulPosStrictMono α :=
   ⟨fun x a b h => lt_of_not_le fun h' => h.not_le <| le_of_mul_le_mul_of_pos_right h' x.Prop⟩
-#align mul_pos_mono_rev.to_mul_pos_strict_mono MulPosMonoRev.toMulPosStrictMono
+#align mul_pos_mono_rev.to_mul_pos_strict_mono MulPosReflectLE.toMulPosStrictMono
 -/
 
-#print posMulStrictMono_iff_posMulMonoRev /-
-theorem posMulStrictMono_iff_posMulMonoRev : PosMulStrictMono α ↔ PosMulMonoRev α :=
-  ⟨@PosMulStrictMono.to_posMulMonoRev _ _ _ _, @PosMulMonoRev.toPosMulStrictMono _ _ _ _⟩
-#align pos_mul_strict_mono_iff_pos_mul_mono_rev posMulStrictMono_iff_posMulMonoRev
+#print posMulStrictMono_iff_posMulReflectLE /-
+theorem posMulStrictMono_iff_posMulReflectLE : PosMulStrictMono α ↔ PosMulReflectLE α :=
+  ⟨@PosMulStrictMono.to_posMulReflectLE _ _ _ _, @PosMulReflectLE.toPosMulStrictMono _ _ _ _⟩
+#align pos_mul_strict_mono_iff_pos_mul_mono_rev posMulStrictMono_iff_posMulReflectLE
 -/
 
-#print mulPosStrictMono_iff_mulPosMonoRev /-
-theorem mulPosStrictMono_iff_mulPosMonoRev : MulPosStrictMono α ↔ MulPosMonoRev α :=
-  ⟨@MulPosStrictMono.to_mulPosMonoRev _ _ _ _, @MulPosMonoRev.toMulPosStrictMono _ _ _ _⟩
-#align mul_pos_strict_mono_iff_mul_pos_mono_rev mulPosStrictMono_iff_mulPosMonoRev
+#print mulPosStrictMono_iff_mulPosReflectLE /-
+theorem mulPosStrictMono_iff_mulPosReflectLE : MulPosStrictMono α ↔ MulPosReflectLE α :=
+  ⟨@MulPosStrictMono.to_mulPosReflectLE _ _ _ _, @MulPosReflectLE.toMulPosStrictMono _ _ _ _⟩
+#align mul_pos_strict_mono_iff_mul_pos_mono_rev mulPosStrictMono_iff_mulPosReflectLE
 -/
 
 #print PosMulReflectLT.toPosMulMono /-
@@ -626,33 +626,35 @@ instance (priority := 100) MulPosStrictMono.toMulPosMono [MulPosStrictMono α] :
 #align mul_pos_strict_mono.to_mul_pos_mono MulPosStrictMono.toMulPosMono
 -/
 
-#print PosMulMonoRev.toPosMulReflectLT /-
+#print PosMulReflectLE.toPosMulReflectLT /-
 -- see Note [lower instance priority]
-instance (priority := 100) PosMulMonoRev.toPosMulReflectLT [PosMulMonoRev α] : PosMulReflectLT α :=
+instance (priority := 100) PosMulReflectLE.toPosMulReflectLT [PosMulReflectLE α] :
+    PosMulReflectLT α :=
   posMulReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
       (le_of_mul_le_mul_of_pos_left h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
-#align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulMonoRev.toPosMulReflectLT
+#align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulReflectLE.toPosMulReflectLT
 -/
 
-#print MulPosMonoRev.toMulPosReflectLT /-
+#print MulPosReflectLE.toMulPosReflectLT /-
 -- see Note [lower instance priority]
-instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] : MulPosReflectLT α :=
+instance (priority := 100) MulPosReflectLE.toMulPosReflectLT [MulPosReflectLE α] :
+    MulPosReflectLT α :=
   mulPosReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
       (le_of_mul_le_mul_of_pos_right h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
-#align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosMonoRev.toMulPosReflectLT
+#align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosReflectLE.toMulPosReflectLT
 -/
 
 #print mul_left_cancel_iff_of_pos /-
-theorem mul_left_cancel_iff_of_pos [PosMulMonoRev α] (a0 : 0 < a) : a * b = a * c ↔ b = c :=
+theorem mul_left_cancel_iff_of_pos [PosMulReflectLE α] (a0 : 0 < a) : a * b = a * c ↔ b = c :=
   ⟨fun h => (le_of_mul_le_mul_of_pos_left h.le a0).antisymm <| le_of_mul_le_mul_of_pos_left h.ge a0,
     congr_arg _⟩
 #align mul_left_cancel_iff_of_pos mul_left_cancel_iff_of_pos
 -/
 
 #print mul_right_cancel_iff_of_pos /-
-theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c * b ↔ a = c :=
+theorem mul_right_cancel_iff_of_pos [MulPosReflectLE α] (b0 : 0 < b) : a * b = c * b ↔ a = c :=
   ⟨fun h =>
     (le_of_mul_le_mul_of_pos_right h.le b0).antisymm <| le_of_mul_le_mul_of_pos_right h.ge b0,
     congr_arg _⟩
@@ -660,8 +662,8 @@ theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c
 -/
 
 #print mul_eq_mul_iff_eq_and_eq_of_pos /-
-theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
-    [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (a0 : 0 < a) (d0 : 0 < d) :
+theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono α]
+    [PosMulReflectLE α] [MulPosReflectLE α] (hac : a ≤ b) (hbd : c ≤ d) (a0 : 0 < a) (d0 : 0 < d) :
     a * c = b * d ↔ a = b ∧ c = d :=
   by
   refine' ⟨fun h => _, fun h => congr_arg₂ (· * ·) h.1 h.2⟩
@@ -674,8 +676,8 @@ theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono
 -/
 
 #print mul_eq_mul_iff_eq_and_eq_of_pos' /-
-theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
-    [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (b0 : 0 < b) (c0 : 0 < c) :
+theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono α]
+    [PosMulReflectLE α] [MulPosReflectLE α] (hac : a ≤ b) (hbd : c ≤ d) (b0 : 0 < b) (c0 : 0 < c) :
     a * c = b * d ↔ a = b ∧ c = d :=
   by
   refine' ⟨fun h => _, fun h => congr_arg₂ (· * ·) h.1 h.2⟩
@@ -766,7 +768,8 @@ which assume left covariance. -/
 
 #print le_mul_iff_one_le_right /-
 @[simp]
-theorem le_mul_iff_one_le_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a ≤ a * b ↔ 1 ≤ b :=
+theorem le_mul_iff_one_le_right [PosMulMono α] [PosMulReflectLE α] (a0 : 0 < a) :
+    a ≤ a * b ↔ 1 ≤ b :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align le_mul_iff_one_le_right le_mul_iff_one_le_right
 -/
@@ -781,7 +784,8 @@ theorem lt_mul_iff_one_lt_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 :
 
 #print mul_le_iff_le_one_right /-
 @[simp]
-theorem mul_le_iff_le_one_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a ↔ b ≤ 1 :=
+theorem mul_le_iff_le_one_right [PosMulMono α] [PosMulReflectLE α] (a0 : 0 < a) :
+    a * b ≤ a ↔ b ≤ 1 :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align mul_le_iff_le_one_right mul_le_iff_le_one_right
 -/
@@ -800,7 +804,8 @@ which assume right covariance. -/
 
 #print le_mul_iff_one_le_left /-
 @[simp]
-theorem le_mul_iff_one_le_left [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : a ≤ b * a ↔ 1 ≤ b :=
+theorem le_mul_iff_one_le_left [MulPosMono α] [MulPosReflectLE α] (a0 : 0 < a) :
+    a ≤ b * a ↔ 1 ≤ b :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right a0)
 #align le_mul_iff_one_le_left le_mul_iff_one_le_left
 -/
@@ -815,7 +820,8 @@ theorem lt_mul_iff_one_lt_left [MulPosStrictMono α] [MulPosReflectLT α] (a0 :
 
 #print mul_le_iff_le_one_left /-
 @[simp]
-theorem mul_le_iff_le_one_left [MulPosMono α] [MulPosMonoRev α] (b0 : 0 < b) : a * b ≤ b ↔ a ≤ 1 :=
+theorem mul_le_iff_le_one_left [MulPosMono α] [MulPosReflectLE α] (b0 : 0 < b) :
+    a * b ≤ b ↔ a ≤ 1 :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right b0)
 #align mul_le_iff_le_one_left mul_le_iff_le_one_left
 -/
@@ -1287,32 +1293,32 @@ theorem mulPosMono_iff_mulPosStrictMono : MulPosMono α ↔ MulPosStrictMono α
 #align mul_pos_mono_iff_mul_pos_strict_mono mulPosMono_iff_mulPosStrictMono
 -/
 
-#print PosMulReflectLT.toPosMulMonoRev /-
-theorem PosMulReflectLT.toPosMulMonoRev [PosMulReflectLT α] : PosMulMonoRev α :=
+#print PosMulReflectLT.toPosMulReflectLE /-
+theorem PosMulReflectLT.toPosMulReflectLE [PosMulReflectLT α] : PosMulReflectLE α :=
   ⟨fun x a b h =>
     h.eq_or_lt.elim (le_of_eq ∘ mul_left_cancel₀ x.2.Ne.symm) fun h' =>
       (lt_of_mul_lt_mul_left h' x.2.le).le⟩
-#align pos_mul_reflect_lt.to_pos_mul_mono_rev PosMulReflectLT.toPosMulMonoRev
+#align pos_mul_reflect_lt.to_pos_mul_mono_rev PosMulReflectLT.toPosMulReflectLE
 -/
 
-#print posMulMonoRev_iff_posMulReflectLT /-
-theorem posMulMonoRev_iff_posMulReflectLT : PosMulMonoRev α ↔ PosMulReflectLT α :=
-  ⟨@PosMulMonoRev.toPosMulReflectLT α _ _, @PosMulReflectLT.toPosMulMonoRev α _ _⟩
-#align pos_mul_mono_rev_iff_pos_mul_reflect_lt posMulMonoRev_iff_posMulReflectLT
+#print posMulReflectLE_iff_posMulReflectLT /-
+theorem posMulReflectLE_iff_posMulReflectLT : PosMulReflectLE α ↔ PosMulReflectLT α :=
+  ⟨@PosMulReflectLE.toPosMulReflectLT α _ _, @PosMulReflectLT.toPosMulReflectLE α _ _⟩
+#align pos_mul_mono_rev_iff_pos_mul_reflect_lt posMulReflectLE_iff_posMulReflectLT
 -/
 
-#print MulPosReflectLT.toMulPosMonoRev /-
-theorem MulPosReflectLT.toMulPosMonoRev [MulPosReflectLT α] : MulPosMonoRev α :=
+#print MulPosReflectLT.toMulPosReflectLE /-
+theorem MulPosReflectLT.toMulPosReflectLE [MulPosReflectLT α] : MulPosReflectLE α :=
   ⟨fun x a b h =>
     h.eq_or_lt.elim (le_of_eq ∘ mul_right_cancel₀ x.2.Ne.symm) fun h' =>
       (lt_of_mul_lt_mul_right h' x.2.le).le⟩
-#align mul_pos_reflect_lt.to_mul_pos_mono_rev MulPosReflectLT.toMulPosMonoRev
+#align mul_pos_reflect_lt.to_mul_pos_mono_rev MulPosReflectLT.toMulPosReflectLE
 -/
 
-#print mulPosMonoRev_iff_mulPosReflectLT /-
-theorem mulPosMonoRev_iff_mulPosReflectLT : MulPosMonoRev α ↔ MulPosReflectLT α :=
-  ⟨@MulPosMonoRev.toMulPosReflectLT α _ _, @MulPosReflectLT.toMulPosMonoRev α _ _⟩
-#align mul_pos_mono_rev_iff_mul_pos_reflect_lt mulPosMonoRev_iff_mulPosReflectLT
+#print mulPosReflectLE_iff_mulPosReflectLT /-
+theorem mulPosReflectLE_iff_mulPosReflectLT : MulPosReflectLE α ↔ MulPosReflectLT α :=
+  ⟨@MulPosReflectLE.toMulPosReflectLT α _ _, @MulPosReflectLT.toMulPosReflectLE α _ _⟩
+#align mul_pos_mono_rev_iff_mul_pos_reflect_lt mulPosReflectLE_iff_mulPosReflectLT
 -/
 
 end PartialOrder
@@ -1340,10 +1346,10 @@ theorem posMulMono_iff_mulPosMono : PosMulMono α ↔ MulPosMono α := by simp!
 #align pos_mul_mono_iff_mul_pos_mono posMulMono_iff_mulPosMono
 -/
 
-#print posMulMonoRev_iff_mulPosMonoRev /-
-theorem posMulMonoRev_iff_mulPosMonoRev : PosMulMonoRev α ↔ MulPosMonoRev α := by
+#print posMulReflectLE_iff_mulPosReflectLE /-
+theorem posMulReflectLE_iff_mulPosReflectLE : PosMulReflectLE α ↔ MulPosReflectLE α := by
   simp! only [mul_comm]
-#align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulMonoRev_iff_mulPosMonoRev
+#align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulReflectLE_iff_mulPosReflectLE
 -/
 
 end CommSemigroupHasZero

44e29dbc

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2022 Damiano Testa. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa, Yuyang Zhao
 -/
-import Mathbin.Algebra.CovariantAndContravariant
-import Mathbin.Algebra.GroupWithZero.Defs
+import Algebra.CovariantAndContravariant
+import Algebra.GroupWithZero.Defs
 
 #align_import algebra.order.ring.lemmas from "leanprover-community/mathlib"@"44e29dbcff83ba7114a464d592b8c3743987c1e5"

44e29dbc

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -218,16 +218,16 @@ theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0
 #align le_of_mul_le_mul_right le_of_mul_le_mul_right
 -/
 
-alias lt_of_mul_lt_mul_left ← lt_of_mul_lt_mul_of_nonneg_left
+alias lt_of_mul_lt_mul_of_nonneg_left := lt_of_mul_lt_mul_left
 #align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_left
 
-alias lt_of_mul_lt_mul_right ← lt_of_mul_lt_mul_of_nonneg_right
+alias lt_of_mul_lt_mul_of_nonneg_right := lt_of_mul_lt_mul_right
 #align lt_of_mul_lt_mul_of_nonneg_right lt_of_mul_lt_mul_of_nonneg_right
 
-alias le_of_mul_le_mul_left ← le_of_mul_le_mul_of_pos_left
+alias le_of_mul_le_mul_of_pos_left := le_of_mul_le_mul_left
 #align le_of_mul_le_mul_of_pos_left le_of_mul_le_mul_of_pos_left
 
-alias le_of_mul_le_mul_right ← le_of_mul_le_mul_of_pos_right
+alias le_of_mul_le_mul_of_pos_right := le_of_mul_le_mul_right
 #align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_right
 
 #print mul_lt_mul_left /-
@@ -427,7 +427,7 @@ theorem Left.mul_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b
 #align left.mul_pos Left.mul_pos
 -/
 
-alias Left.mul_pos ← mul_pos
+alias mul_pos := Left.mul_pos
 #align mul_pos mul_pos
 
 #print mul_neg_of_pos_of_neg /-
@@ -470,7 +470,7 @@ theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a
 #align left.mul_nonneg Left.mul_nonneg
 -/
 
-alias Left.mul_nonneg ← mul_nonneg
+alias mul_nonneg := Left.mul_nonneg
 #align mul_nonneg mul_nonneg
 
 #print mul_nonpos_of_nonneg_of_nonpos /-

44e29dbc

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Damiano Testa. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa, Yuyang Zhao
-
-! This file was ported from Lean 3 source module algebra.order.ring.lemmas
-! leanprover-community/mathlib commit 44e29dbcff83ba7114a464d592b8c3743987c1e5
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Algebra.CovariantAndContravariant
 import Mathbin.Algebra.GroupWithZero.Defs
 
+#align_import algebra.order.ring.lemmas from "leanprover-community/mathlib"@"44e29dbcff83ba7114a464d592b8c3743987c1e5"
+
 /-!
 # Multiplication by ·positive· elements is monotonic

44e29dbc

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -57,14 +57,12 @@ The following is local notation in this file:
 
 variable (α : Type _)
 
--- mathport name: «exprα≥0»
 /- Notations for nonnegative and positive elements
 https://
 leanprover.zulipchat.com/#narrow/stream/113488-general/topic/notation.20for.20positive.20elements
 -/
 local notation "α≥0" => { x : α // 0 ≤ x }
 
--- mathport name: «exprα>0»
 local notation "α>0" => { x : α // 0 < x }
 
 section Abbreviations
@@ -425,105 +423,145 @@ section Preorder
 
 variable [Preorder α]
 
+#print Left.mul_pos /-
 /-- Assumes left covariance. -/
 theorem Left.mul_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
   simpa only [MulZeroClass.mul_zero] using mul_lt_mul_of_pos_left hb ha
 #align left.mul_pos Left.mul_pos
+-/
 
 alias Left.mul_pos ← mul_pos
 #align mul_pos mul_pos
 
+#print mul_neg_of_pos_of_neg /-
 theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) : a * b < 0 := by
   simpa only [MulZeroClass.mul_zero] using mul_lt_mul_of_pos_left hb ha
 #align mul_neg_of_pos_of_neg mul_neg_of_pos_of_neg
+-/
 
+#print zero_lt_mul_left /-
 @[simp]
 theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) : 0 < c * b ↔ 0 < b :=
   by convert mul_lt_mul_left h; simp
 #align zero_lt_mul_left zero_lt_mul_left
+-/
 
+#print Right.mul_pos /-
 /-- Assumes right covariance. -/
 theorem Right.mul_pos [MulPosStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
   simpa only [MulZeroClass.zero_mul] using mul_lt_mul_of_pos_right ha hb
 #align right.mul_pos Right.mul_pos
+-/
 
+#print mul_neg_of_neg_of_pos /-
 theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) : a * b < 0 := by
   simpa only [MulZeroClass.zero_mul] using mul_lt_mul_of_pos_right ha hb
 #align mul_neg_of_neg_of_pos mul_neg_of_neg_of_pos
+-/
 
+#print zero_lt_mul_right /-
 @[simp]
 theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
     0 < b * c ↔ 0 < b := by convert mul_lt_mul_right h; simp
 #align zero_lt_mul_right zero_lt_mul_right
+-/
 
+#print Left.mul_nonneg /-
 /-- Assumes left covariance. -/
 theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
   simpa only [MulZeroClass.mul_zero] using mul_le_mul_of_nonneg_left hb ha
 #align left.mul_nonneg Left.mul_nonneg
+-/
 
 alias Left.mul_nonneg ← mul_nonneg
 #align mul_nonneg mul_nonneg
 
+#print mul_nonpos_of_nonneg_of_nonpos /-
 theorem mul_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0 := by
   simpa only [MulZeroClass.mul_zero] using mul_le_mul_of_nonneg_left hb ha
 #align mul_nonpos_of_nonneg_of_nonpos mul_nonpos_of_nonneg_of_nonpos
+-/
 
+#print Right.mul_nonneg /-
 /-- Assumes right covariance. -/
 theorem Right.mul_nonneg [MulPosMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
   simpa only [MulZeroClass.zero_mul] using mul_le_mul_of_nonneg_right ha hb
 #align right.mul_nonneg Right.mul_nonneg
+-/
 
+#print mul_nonpos_of_nonpos_of_nonneg /-
 theorem mul_nonpos_of_nonpos_of_nonneg [MulPosMono α] (ha : a ≤ 0) (hb : 0 ≤ b) : a * b ≤ 0 := by
   simpa only [MulZeroClass.zero_mul] using mul_le_mul_of_nonneg_right ha hb
 #align mul_nonpos_of_nonpos_of_nonneg mul_nonpos_of_nonpos_of_nonneg
+-/
 
+#print pos_of_mul_pos_right /-
 theorem pos_of_mul_pos_right [PosMulReflectLT α] (h : 0 < a * b) (ha : 0 ≤ a) : 0 < b :=
   lt_of_mul_lt_mul_left ((MulZeroClass.mul_zero a).symm ▸ h : a * 0 < a * b) ha
 #align pos_of_mul_pos_right pos_of_mul_pos_right
+-/
 
+#print pos_of_mul_pos_left /-
 theorem pos_of_mul_pos_left [MulPosReflectLT α] (h : 0 < a * b) (hb : 0 ≤ b) : 0 < a :=
   lt_of_mul_lt_mul_right ((MulZeroClass.zero_mul b).symm ▸ h : 0 * b < a * b) hb
 #align pos_of_mul_pos_left pos_of_mul_pos_left
+-/
 
+#print pos_iff_pos_of_mul_pos /-
 theorem pos_iff_pos_of_mul_pos [PosMulReflectLT α] [MulPosReflectLT α] (hab : 0 < a * b) :
     0 < a ↔ 0 < b :=
   ⟨pos_of_mul_pos_right hab ∘ le_of_lt, pos_of_mul_pos_left hab ∘ le_of_lt⟩
 #align pos_iff_pos_of_mul_pos pos_iff_pos_of_mul_pos
+-/
 
+#print mul_le_mul_of_le_of_le /-
 theorem mul_le_mul_of_le_of_le [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (a0 : 0 ≤ a)
     (d0 : 0 ≤ d) : a * c ≤ b * d :=
   (mul_le_mul_of_nonneg_left h₂ a0).trans <| mul_le_mul_of_nonneg_right h₁ d0
 #align mul_le_mul_of_le_of_le mul_le_mul_of_le_of_le
+-/
 
+#print mul_le_mul /-
 theorem mul_le_mul [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (c0 : 0 ≤ c)
     (b0 : 0 ≤ b) : a * c ≤ b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans <| mul_le_mul_of_nonneg_left h₂ b0
 #align mul_le_mul mul_le_mul
+-/
 
+#print mul_self_le_mul_self /-
 theorem mul_self_le_mul_self [PosMulMono α] [MulPosMono α] (ha : 0 ≤ a) (hab : a ≤ b) :
     a * a ≤ b * b :=
   mul_le_mul hab hab ha <| ha.trans hab
 #align mul_self_le_mul_self mul_self_le_mul_self
+-/
 
+#print mul_le_of_mul_le_of_nonneg_left /-
 theorem mul_le_of_mul_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hle : d ≤ b) (a0 : 0 ≤ a) :
     a * d ≤ c :=
   (mul_le_mul_of_nonneg_left hle a0).trans h
 #align mul_le_of_mul_le_of_nonneg_left mul_le_of_mul_le_of_nonneg_left
+-/
 
+#print le_mul_of_le_mul_of_nonneg_left /-
 theorem le_mul_of_le_mul_of_nonneg_left [PosMulMono α] (h : a ≤ b * c) (hle : c ≤ d) (b0 : 0 ≤ b) :
     a ≤ b * d :=
   h.trans (mul_le_mul_of_nonneg_left hle b0)
 #align le_mul_of_le_mul_of_nonneg_left le_mul_of_le_mul_of_nonneg_left
+-/
 
+#print mul_le_of_mul_le_of_nonneg_right /-
 theorem mul_le_of_mul_le_of_nonneg_right [MulPosMono α] (h : a * b ≤ c) (hle : d ≤ a) (b0 : 0 ≤ b) :
     d * b ≤ c :=
   (mul_le_mul_of_nonneg_right hle b0).trans h
 #align mul_le_of_mul_le_of_nonneg_right mul_le_of_mul_le_of_nonneg_right
+-/
 
+#print le_mul_of_le_mul_of_nonneg_right /-
 theorem le_mul_of_le_mul_of_nonneg_right [MulPosMono α] (h : a ≤ b * c) (hle : b ≤ d) (c0 : 0 ≤ c) :
     a ≤ d * c :=
   h.trans (mul_le_mul_of_nonneg_right hle c0)
 #align le_mul_of_le_mul_of_nonneg_right le_mul_of_le_mul_of_nonneg_right
+-/
 
 end Preorder
 
@@ -531,6 +569,7 @@ section PartialOrder
 
 variable [PartialOrder α]
 
+#print posMulMono_iff_covariant_pos /-
 theorem posMulMono_iff_covariant_pos :
     PosMulMono α ↔ CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
   ⟨@PosMulMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
@@ -539,7 +578,9 @@ theorem posMulMono_iff_covariant_pos :
       · simp only [ha, MulZeroClass.zero_mul]
       · exact @CovariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align pos_mul_mono_iff_covariant_pos posMulMono_iff_covariant_pos
+-/
 
+#print mulPosMono_iff_covariant_pos /-
 theorem mulPosMono_iff_covariant_pos :
     MulPosMono α ↔ CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
   ⟨@MulPosMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
@@ -548,7 +589,9 @@ theorem mulPosMono_iff_covariant_pos :
       · simp only [ha, MulZeroClass.mul_zero]
       · exact @CovariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align mul_pos_mono_iff_covariant_pos mulPosMono_iff_covariant_pos
+-/
 
+#print posMulReflectLT_iff_contravariant_pos /-
 theorem posMulReflectLT_iff_contravariant_pos :
     PosMulReflectLT α ↔ ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
   ⟨@PosMulReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
@@ -557,7 +600,9 @@ theorem posMulReflectLT_iff_contravariant_pos :
       · simpa [ha] using h
       · exact @ContravariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align pos_mul_reflect_lt_iff_contravariant_pos posMulReflectLT_iff_contravariant_pos
+-/
 
+#print mulPosReflectLT_iff_contravariant_pos /-
 theorem mulPosReflectLT_iff_contravariant_pos :
     MulPosReflectLT α ↔ ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
   ⟨@MulPosReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
@@ -566,44 +611,58 @@ theorem mulPosReflectLT_iff_contravariant_pos :
       · simpa [ha] using h
       · exact @ContravariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align mul_pos_reflect_lt_iff_contravariant_pos mulPosReflectLT_iff_contravariant_pos
+-/
 
+#print PosMulStrictMono.toPosMulMono /-
 -- see Note [lower instance priority]
 instance (priority := 100) PosMulStrictMono.toPosMulMono [PosMulStrictMono α] : PosMulMono α :=
   posMulMono_iff_covariant_pos.2 <|
     ⟨fun a => StrictMono.monotone <| @CovariantClass.elim _ _ _ _ _ _⟩
 #align pos_mul_strict_mono.to_pos_mul_mono PosMulStrictMono.toPosMulMono
+-/
 
+#print MulPosStrictMono.toMulPosMono /-
 -- see Note [lower instance priority]
 instance (priority := 100) MulPosStrictMono.toMulPosMono [MulPosStrictMono α] : MulPosMono α :=
   mulPosMono_iff_covariant_pos.2 <|
     ⟨fun a => StrictMono.monotone <| @CovariantClass.elim _ _ _ _ _ _⟩
 #align mul_pos_strict_mono.to_mul_pos_mono MulPosStrictMono.toMulPosMono
+-/
 
+#print PosMulMonoRev.toPosMulReflectLT /-
 -- see Note [lower instance priority]
 instance (priority := 100) PosMulMonoRev.toPosMulReflectLT [PosMulMonoRev α] : PosMulReflectLT α :=
   posMulReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
       (le_of_mul_le_mul_of_pos_left h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
 #align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulMonoRev.toPosMulReflectLT
+-/
 
+#print MulPosMonoRev.toMulPosReflectLT /-
 -- see Note [lower instance priority]
 instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] : MulPosReflectLT α :=
   mulPosReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
       (le_of_mul_le_mul_of_pos_right h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
 #align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosMonoRev.toMulPosReflectLT
+-/
 
+#print mul_left_cancel_iff_of_pos /-
 theorem mul_left_cancel_iff_of_pos [PosMulMonoRev α] (a0 : 0 < a) : a * b = a * c ↔ b = c :=
   ⟨fun h => (le_of_mul_le_mul_of_pos_left h.le a0).antisymm <| le_of_mul_le_mul_of_pos_left h.ge a0,
     congr_arg _⟩
 #align mul_left_cancel_iff_of_pos mul_left_cancel_iff_of_pos
+-/
 
+#print mul_right_cancel_iff_of_pos /-
 theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c * b ↔ a = c :=
   ⟨fun h =>
     (le_of_mul_le_mul_of_pos_right h.le b0).antisymm <| le_of_mul_le_mul_of_pos_right h.ge b0,
     congr_arg _⟩
 #align mul_right_cancel_iff_of_pos mul_right_cancel_iff_of_pos
+-/
 
+#print mul_eq_mul_iff_eq_and_eq_of_pos /-
 theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
     [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (a0 : 0 < a) (d0 : 0 < d) :
     a * c = b * d ↔ a = b ∧ c = d :=
@@ -615,7 +674,9 @@ theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono
   · exact ⟨(mul_right_cancel_iff_of_pos d0).mp h, rfl⟩
   exact ((mul_lt_mul_of_pos_of_pos hac hbd a0 d0).Ne h).elim
 #align mul_eq_mul_iff_eq_and_eq_of_pos mul_eq_mul_iff_eq_and_eq_of_pos
+-/
 
+#print mul_eq_mul_iff_eq_and_eq_of_pos' /-
 theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
     [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (b0 : 0 < b) (c0 : 0 < c) :
     a * c = b * d ↔ a = b ∧ c = d :=
@@ -627,6 +688,7 @@ theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono
   · exact ⟨(mul_right_cancel_iff_of_pos c0).mp h, rfl⟩
   exact ((mul_lt_mul_of_lt_of_lt' hac hbd b0 c0).Ne h).elim
 #align mul_eq_mul_iff_eq_and_eq_of_pos' mul_eq_mul_iff_eq_and_eq_of_pos'
+-/
 
 end PartialOrder
 
@@ -634,6 +696,7 @@ section LinearOrder
 
 variable [LinearOrder α]
 
+#print pos_and_pos_or_neg_and_neg_of_mul_pos /-
 theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b) :
     0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 :=
   by
@@ -644,34 +707,49 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
   · refine' Or.inr ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonpos_of_nonneg ha.le hb
 #align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_pos
+-/
 
+#print neg_of_mul_pos_right /-
 theorem neg_of_mul_pos_right [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha : a ≤ 0) : b < 0 :=
   ((pos_and_pos_or_neg_and_neg_of_mul_pos h).resolve_left fun h => h.1.not_le ha).2
 #align neg_of_mul_pos_right neg_of_mul_pos_right
+-/
 
+#print neg_of_mul_pos_left /-
 theorem neg_of_mul_pos_left [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha : b ≤ 0) : a < 0 :=
   ((pos_and_pos_or_neg_and_neg_of_mul_pos h).resolve_left fun h => h.2.not_le ha).1
 #align neg_of_mul_pos_left neg_of_mul_pos_left
+-/
 
+#print neg_iff_neg_of_mul_pos /-
 theorem neg_iff_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b) : a < 0 ↔ b < 0 :=
   ⟨neg_of_mul_pos_right hab ∘ le_of_lt, neg_of_mul_pos_left hab ∘ le_of_lt⟩
 #align neg_iff_neg_of_mul_pos neg_iff_neg_of_mul_pos
+-/
 
+#print Left.neg_of_mul_neg_left /-
 theorem Left.neg_of_mul_neg_left [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ a) : b < 0 :=
   lt_of_not_ge fun h2 : b ≥ 0 => (Left.mul_nonneg h1 h2).not_lt h
 #align left.neg_of_mul_neg_left Left.neg_of_mul_neg_left
+-/
 
+#print Right.neg_of_mul_neg_left /-
 theorem Right.neg_of_mul_neg_left [MulPosMono α] (h : a * b < 0) (h1 : 0 ≤ a) : b < 0 :=
   lt_of_not_ge fun h2 : b ≥ 0 => (Right.mul_nonneg h1 h2).not_lt h
 #align right.neg_of_mul_neg_left Right.neg_of_mul_neg_left
+-/
 
+#print Left.neg_of_mul_neg_right /-
 theorem Left.neg_of_mul_neg_right [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ b) : a < 0 :=
   lt_of_not_ge fun h2 : a ≥ 0 => (Left.mul_nonneg h2 h1).not_lt h
 #align left.neg_of_mul_neg_right Left.neg_of_mul_neg_right
+-/
 
+#print Right.neg_of_mul_neg_right /-
 theorem Right.neg_of_mul_neg_right [MulPosMono α] (h : a * b < 0) (h1 : 0 ≤ b) : a < 0 :=
   lt_of_not_ge fun h2 : a ≥ 0 => (Right.mul_nonneg h2 h1).not_lt h
 #align right.neg_of_mul_neg_right Right.neg_of_mul_neg_right
+-/
 
 end LinearOrder
 
@@ -689,53 +767,69 @@ variable [Preorder α]
 which assume left covariance. -/
 
 
+#print le_mul_iff_one_le_right /-
 @[simp]
 theorem le_mul_iff_one_le_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a ≤ a * b ↔ 1 ≤ b :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align le_mul_iff_one_le_right le_mul_iff_one_le_right
+-/
 
+#print lt_mul_iff_one_lt_right /-
 @[simp]
 theorem lt_mul_iff_one_lt_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a < a * b ↔ 1 < b :=
   Iff.trans (by rw [mul_one]) (mul_lt_mul_left a0)
 #align lt_mul_iff_one_lt_right lt_mul_iff_one_lt_right
+-/
 
+#print mul_le_iff_le_one_right /-
 @[simp]
 theorem mul_le_iff_le_one_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a ↔ b ≤ 1 :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align mul_le_iff_le_one_right mul_le_iff_le_one_right
+-/
 
+#print mul_lt_iff_lt_one_right /-
 @[simp]
 theorem mul_lt_iff_lt_one_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a * b < a ↔ b < 1 :=
   Iff.trans (by rw [mul_one]) (mul_lt_mul_left a0)
 #align mul_lt_iff_lt_one_right mul_lt_iff_lt_one_right
+-/
 
 /-! Lemmas of the form `a ≤ b * a ↔ 1 ≤ b` and `a * b ≤ b ↔ a ≤ 1`,
 which assume right covariance. -/
 
 
+#print le_mul_iff_one_le_left /-
 @[simp]
 theorem le_mul_iff_one_le_left [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : a ≤ b * a ↔ 1 ≤ b :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right a0)
 #align le_mul_iff_one_le_left le_mul_iff_one_le_left
+-/
 
+#print lt_mul_iff_one_lt_left /-
 @[simp]
 theorem lt_mul_iff_one_lt_left [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a) :
     a < b * a ↔ 1 < b :=
   Iff.trans (by rw [one_mul]) (mul_lt_mul_right a0)
 #align lt_mul_iff_one_lt_left lt_mul_iff_one_lt_left
+-/
 
+#print mul_le_iff_le_one_left /-
 @[simp]
 theorem mul_le_iff_le_one_left [MulPosMono α] [MulPosMonoRev α] (b0 : 0 < b) : a * b ≤ b ↔ a ≤ 1 :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right b0)
 #align mul_le_iff_le_one_left mul_le_iff_le_one_left
+-/
 
+#print mul_lt_iff_lt_one_left /-
 @[simp]
 theorem mul_lt_iff_lt_one_left [MulPosStrictMono α] [MulPosReflectLT α] (b0 : 0 < b) :
     a * b < b ↔ a < 1 :=
   Iff.trans (by rw [one_mul]) (mul_lt_mul_right b0)
 #align mul_lt_iff_lt_one_left mul_lt_iff_lt_one_left
+-/
 
 /-! Lemmas of the form `1 ≤ b → a ≤ a * b`.
 
@@ -743,41 +837,58 @@ Variants with `< 0` and `≤ 0` instead of `0 <` and `0 ≤` appear in `algebra/
 imports this file) as they need additional results which are not yet available here. -/
 
 
+#print mul_le_of_le_one_left /-
 theorem mul_le_of_le_one_left [MulPosMono α] (hb : 0 ≤ b) (h : a ≤ 1) : a * b ≤ b := by
   simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
 #align mul_le_of_le_one_left mul_le_of_le_one_left
+-/
 
+#print le_mul_of_one_le_left /-
 theorem le_mul_of_one_le_left [MulPosMono α] (hb : 0 ≤ b) (h : 1 ≤ a) : b ≤ a * b := by
   simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
 #align le_mul_of_one_le_left le_mul_of_one_le_left
+-/
 
+#print mul_le_of_le_one_right /-
 theorem mul_le_of_le_one_right [PosMulMono α] (ha : 0 ≤ a) (h : b ≤ 1) : a * b ≤ a := by
   simpa only [mul_one] using mul_le_mul_of_nonneg_left h ha
 #align mul_le_of_le_one_right mul_le_of_le_one_right
+-/
 
+#print le_mul_of_one_le_right /-
 theorem le_mul_of_one_le_right [PosMulMono α] (ha : 0 ≤ a) (h : 1 ≤ b) : a ≤ a * b := by
   simpa only [mul_one] using mul_le_mul_of_nonneg_left h ha
 #align le_mul_of_one_le_right le_mul_of_one_le_right
+-/
 
+#print mul_lt_of_lt_one_left /-
 theorem mul_lt_of_lt_one_left [MulPosStrictMono α] (hb : 0 < b) (h : a < 1) : a * b < b := by
   simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
 #align mul_lt_of_lt_one_left mul_lt_of_lt_one_left
+-/
 
+#print lt_mul_of_one_lt_left /-
 theorem lt_mul_of_one_lt_left [MulPosStrictMono α] (hb : 0 < b) (h : 1 < a) : b < a * b := by
   simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
 #align lt_mul_of_one_lt_left lt_mul_of_one_lt_left
+-/
 
+#print mul_lt_of_lt_one_right /-
 theorem mul_lt_of_lt_one_right [PosMulStrictMono α] (ha : 0 < a) (h : b < 1) : a * b < a := by
   simpa only [mul_one] using mul_lt_mul_of_pos_left h ha
 #align mul_lt_of_lt_one_right mul_lt_of_lt_one_right
+-/
 
+#print lt_mul_of_one_lt_right /-
 theorem lt_mul_of_one_lt_right [PosMulStrictMono α] (ha : 0 < a) (h : 1 < b) : a < a * b := by
   simpa only [mul_one] using mul_lt_mul_of_pos_left h ha
 #align lt_mul_of_one_lt_right lt_mul_of_one_lt_right
+-/
 
 /-! Lemmas of the form `b ≤ c → a ≤ 1 → b * a ≤ c`. -/
 
 
+#print mul_le_of_le_of_le_one_of_nonneg /-
 /- Yaël: What's the point of these lemmas? They just chain an existing lemma with an assumption in
 all possible ways, thereby artificially inflating the API and making the truly relevant lemmas hard
 to find -/
@@ -785,253 +896,344 @@ theorem mul_le_of_le_of_le_one_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : a 
     b * a ≤ c :=
   (mul_le_of_le_one_right hb ha).trans h
 #align mul_le_of_le_of_le_one_of_nonneg mul_le_of_le_of_le_one_of_nonneg
+-/
 
+#print mul_lt_of_le_of_lt_one_of_pos /-
 theorem mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha : a < 1) (b0 : 0 < b) :
     b * a < c :=
   (mul_lt_of_lt_one_right b0 ha).trans_le bc
 #align mul_lt_of_le_of_lt_one_of_pos mul_lt_of_le_of_lt_one_of_pos
+-/
 
+#print mul_lt_of_lt_of_le_one_of_nonneg /-
 theorem mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (h : b < c) (ha : a ≤ 1) (hb : 0 ≤ b) :
     b * a < c :=
   (mul_le_of_le_one_right hb ha).trans_lt h
 #align mul_lt_of_lt_of_le_one_of_nonneg mul_lt_of_lt_of_le_one_of_nonneg
+-/
 
+#print Left.mul_le_one_of_le_of_le /-
 /-- Assumes left covariance. -/
 theorem Left.mul_le_one_of_le_of_le [PosMulMono α] (ha : a ≤ 1) (hb : b ≤ 1) (a0 : 0 ≤ a) :
     a * b ≤ 1 :=
   mul_le_of_le_of_le_one_of_nonneg ha hb a0
 #align left.mul_le_one_of_le_of_le Left.mul_le_one_of_le_of_le
+-/
 
+#print Left.mul_lt_of_le_of_lt_one_of_pos /-
 /-- Assumes left covariance. -/
 theorem Left.mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (ha : a ≤ 1) (hb : b < 1)
     (a0 : 0 < a) : a * b < 1 :=
   mul_lt_of_le_of_lt_one_of_pos ha hb a0
 #align left.mul_lt_of_le_of_lt_one_of_pos Left.mul_lt_of_le_of_lt_one_of_pos
+-/
 
+#print Left.mul_lt_of_lt_of_le_one_of_nonneg /-
 /-- Assumes left covariance. -/
 theorem Left.mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (ha : a < 1) (hb : b ≤ 1)
     (a0 : 0 ≤ a) : a * b < 1 :=
   mul_lt_of_lt_of_le_one_of_nonneg ha hb a0
 #align left.mul_lt_of_lt_of_le_one_of_nonneg Left.mul_lt_of_lt_of_le_one_of_nonneg
+-/
 
+#print mul_le_of_le_of_le_one' /-
 theorem mul_le_of_le_of_le_one' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (ha : a ≤ 1) (a0 : 0 ≤ a)
     (c0 : 0 ≤ c) : b * a ≤ c :=
   (mul_le_mul_of_nonneg_right bc a0).trans <| mul_le_of_le_one_right c0 ha
 #align mul_le_of_le_of_le_one' mul_le_of_le_of_le_one'
+-/
 
+#print mul_lt_of_lt_of_le_one' /-
 theorem mul_lt_of_lt_of_le_one' [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : a ≤ 1)
     (a0 : 0 < a) (c0 : 0 ≤ c) : b * a < c :=
   (mul_lt_mul_of_pos_right bc a0).trans_le <| mul_le_of_le_one_right c0 ha
 #align mul_lt_of_lt_of_le_one' mul_lt_of_lt_of_le_one'
+-/
 
+#print mul_lt_of_le_of_lt_one' /-
 theorem mul_lt_of_le_of_lt_one' [PosMulStrictMono α] [MulPosMono α] (bc : b ≤ c) (ha : a < 1)
     (a0 : 0 ≤ a) (c0 : 0 < c) : b * a < c :=
   (mul_le_mul_of_nonneg_right bc a0).trans_lt <| mul_lt_of_lt_one_right c0 ha
 #align mul_lt_of_le_of_lt_one' mul_lt_of_le_of_lt_one'
+-/
 
+#print mul_lt_of_lt_of_lt_one_of_pos /-
 theorem mul_lt_of_lt_of_lt_one_of_pos [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : a ≤ 1)
     (a0 : 0 < a) (c0 : 0 ≤ c) : b * a < c :=
   (mul_lt_mul_of_pos_right bc a0).trans_le <| mul_le_of_le_one_right c0 ha
 #align mul_lt_of_lt_of_lt_one_of_pos mul_lt_of_lt_of_lt_one_of_pos
+-/
 
 /-! Lemmas of the form `b ≤ c → 1 ≤ a → b ≤ c * a`. -/
 
 
+#print le_mul_of_le_of_one_le_of_nonneg /-
 theorem le_mul_of_le_of_one_le_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : 1 ≤ a) (hc : 0 ≤ c) :
     b ≤ c * a :=
   h.trans <| le_mul_of_one_le_right hc ha
 #align le_mul_of_le_of_one_le_of_nonneg le_mul_of_le_of_one_le_of_nonneg
+-/
 
+#print lt_mul_of_le_of_one_lt_of_pos /-
 theorem lt_mul_of_le_of_one_lt_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha : 1 < a) (c0 : 0 < c) :
     b < c * a :=
   bc.trans_lt <| lt_mul_of_one_lt_right c0 ha
 #align lt_mul_of_le_of_one_lt_of_pos lt_mul_of_le_of_one_lt_of_pos
+-/
 
+#print lt_mul_of_lt_of_one_le_of_nonneg /-
 theorem lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (h : b < c) (ha : 1 ≤ a) (hc : 0 ≤ c) :
     b < c * a :=
   h.trans_le <| le_mul_of_one_le_right hc ha
 #align lt_mul_of_lt_of_one_le_of_nonneg lt_mul_of_lt_of_one_le_of_nonneg
+-/
 
+#print Left.one_le_mul_of_le_of_le /-
 /-- Assumes left covariance. -/
 theorem Left.one_le_mul_of_le_of_le [PosMulMono α] (ha : 1 ≤ a) (hb : 1 ≤ b) (a0 : 0 ≤ a) :
     1 ≤ a * b :=
   le_mul_of_le_of_one_le_of_nonneg ha hb a0
 #align left.one_le_mul_of_le_of_le Left.one_le_mul_of_le_of_le
+-/
 
+#print Left.one_lt_mul_of_le_of_lt_of_pos /-
 /-- Assumes left covariance. -/
 theorem Left.one_lt_mul_of_le_of_lt_of_pos [PosMulStrictMono α] (ha : 1 ≤ a) (hb : 1 < b)
     (a0 : 0 < a) : 1 < a * b :=
   lt_mul_of_le_of_one_lt_of_pos ha hb a0
 #align left.one_lt_mul_of_le_of_lt_of_pos Left.one_lt_mul_of_le_of_lt_of_pos
+-/
 
+#print Left.lt_mul_of_lt_of_one_le_of_nonneg /-
 /-- Assumes left covariance. -/
 theorem Left.lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (ha : 1 < a) (hb : 1 ≤ b)
     (a0 : 0 ≤ a) : 1 < a * b :=
   lt_mul_of_lt_of_one_le_of_nonneg ha hb a0
 #align left.lt_mul_of_lt_of_one_le_of_nonneg Left.lt_mul_of_lt_of_one_le_of_nonneg
+-/
 
+#print le_mul_of_le_of_one_le' /-
 theorem le_mul_of_le_of_one_le' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (ha : 1 ≤ a) (a0 : 0 ≤ a)
     (b0 : 0 ≤ b) : b ≤ c * a :=
   (le_mul_of_one_le_right b0 ha).trans <| mul_le_mul_of_nonneg_right bc a0
 #align le_mul_of_le_of_one_le' le_mul_of_le_of_one_le'
+-/
 
+#print lt_mul_of_le_of_one_lt' /-
 theorem lt_mul_of_le_of_one_lt' [PosMulStrictMono α] [MulPosMono α] (bc : b ≤ c) (ha : 1 < a)
     (a0 : 0 ≤ a) (b0 : 0 < b) : b < c * a :=
   (lt_mul_of_one_lt_right b0 ha).trans_le <| mul_le_mul_of_nonneg_right bc a0
 #align lt_mul_of_le_of_one_lt' lt_mul_of_le_of_one_lt'
+-/
 
+#print lt_mul_of_lt_of_one_le' /-
 theorem lt_mul_of_lt_of_one_le' [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : 1 ≤ a)
     (a0 : 0 < a) (b0 : 0 ≤ b) : b < c * a :=
   (le_mul_of_one_le_right b0 ha).trans_lt <| mul_lt_mul_of_pos_right bc a0
 #align lt_mul_of_lt_of_one_le' lt_mul_of_lt_of_one_le'
+-/
 
+#print lt_mul_of_lt_of_one_lt_of_pos /-
 theorem lt_mul_of_lt_of_one_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (bc : b < c)
     (ha : 1 < a) (a0 : 0 < a) (b0 : 0 < b) : b < c * a :=
   (lt_mul_of_one_lt_right b0 ha).trans <| mul_lt_mul_of_pos_right bc a0
 #align lt_mul_of_lt_of_one_lt_of_pos lt_mul_of_lt_of_one_lt_of_pos
+-/
 
 /-! Lemmas of the form `a ≤ 1 → b ≤ c → a * b ≤ c`. -/
 
 
+#print mul_le_of_le_one_of_le_of_nonneg /-
 theorem mul_le_of_le_one_of_le_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b ≤ c) (hb : 0 ≤ b) :
     a * b ≤ c :=
   (mul_le_of_le_one_left hb ha).trans h
 #align mul_le_of_le_one_of_le_of_nonneg mul_le_of_le_one_of_le_of_nonneg
+-/
 
+#print mul_lt_of_lt_one_of_le_of_pos /-
 theorem mul_lt_of_lt_one_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (h : b ≤ c) (hb : 0 < b) :
     a * b < c :=
   (mul_lt_of_lt_one_left hb ha).trans_le h
 #align mul_lt_of_lt_one_of_le_of_pos mul_lt_of_lt_one_of_le_of_pos
+-/
 
+#print mul_lt_of_le_one_of_lt_of_nonneg /-
 theorem mul_lt_of_le_one_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b < c) (hb : 0 ≤ b) :
     a * b < c :=
   (mul_le_of_le_one_left hb ha).trans_lt h
 #align mul_lt_of_le_one_of_lt_of_nonneg mul_lt_of_le_one_of_lt_of_nonneg
+-/
 
+#print Right.mul_lt_one_of_lt_of_le_of_pos /-
 /-- Assumes right covariance. -/
 theorem Right.mul_lt_one_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (hb : b ≤ 1)
     (b0 : 0 < b) : a * b < 1 :=
   mul_lt_of_lt_one_of_le_of_pos ha hb b0
 #align right.mul_lt_one_of_lt_of_le_of_pos Right.mul_lt_one_of_lt_of_le_of_pos
+-/
 
+#print Right.mul_lt_one_of_le_of_lt_of_nonneg /-
 /-- Assumes right covariance. -/
 theorem Right.mul_lt_one_of_le_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (hb : b < 1)
     (b0 : 0 ≤ b) : a * b < 1 :=
   mul_lt_of_le_one_of_lt_of_nonneg ha hb b0
 #align right.mul_lt_one_of_le_of_lt_of_nonneg Right.mul_lt_one_of_le_of_lt_of_nonneg
+-/
 
+#print mul_lt_of_lt_one_of_lt_of_pos /-
 theorem mul_lt_of_lt_one_of_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (ha : a < 1)
     (bc : b < c) (a0 : 0 < a) (c0 : 0 < c) : a * b < c :=
   (mul_lt_mul_of_pos_left bc a0).trans <| mul_lt_of_lt_one_left c0 ha
 #align mul_lt_of_lt_one_of_lt_of_pos mul_lt_of_lt_one_of_lt_of_pos
+-/
 
+#print Right.mul_le_one_of_le_of_le /-
 /-- Assumes right covariance. -/
 theorem Right.mul_le_one_of_le_of_le [MulPosMono α] (ha : a ≤ 1) (hb : b ≤ 1) (b0 : 0 ≤ b) :
     a * b ≤ 1 :=
   mul_le_of_le_one_of_le_of_nonneg ha hb b0
 #align right.mul_le_one_of_le_of_le Right.mul_le_one_of_le_of_le
+-/
 
+#print mul_le_of_le_one_of_le' /-
 theorem mul_le_of_le_one_of_le' [PosMulMono α] [MulPosMono α] (ha : a ≤ 1) (bc : b ≤ c) (a0 : 0 ≤ a)
     (c0 : 0 ≤ c) : a * b ≤ c :=
   (mul_le_mul_of_nonneg_left bc a0).trans <| mul_le_of_le_one_left c0 ha
 #align mul_le_of_le_one_of_le' mul_le_of_le_one_of_le'
+-/
 
+#print mul_lt_of_lt_one_of_le' /-
 theorem mul_lt_of_lt_one_of_le' [PosMulMono α] [MulPosStrictMono α] (ha : a < 1) (bc : b ≤ c)
     (a0 : 0 ≤ a) (c0 : 0 < c) : a * b < c :=
   (mul_le_mul_of_nonneg_left bc a0).trans_lt <| mul_lt_of_lt_one_left c0 ha
 #align mul_lt_of_lt_one_of_le' mul_lt_of_lt_one_of_le'
+-/
 
+#print mul_lt_of_le_one_of_lt' /-
 theorem mul_lt_of_le_one_of_lt' [PosMulStrictMono α] [MulPosMono α] (ha : a ≤ 1) (bc : b < c)
     (a0 : 0 < a) (c0 : 0 ≤ c) : a * b < c :=
   (mul_lt_mul_of_pos_left bc a0).trans_le <| mul_le_of_le_one_left c0 ha
 #align mul_lt_of_le_one_of_lt' mul_lt_of_le_one_of_lt'
+-/
 
 /-! Lemmas of the form `1 ≤ a → b ≤ c → b ≤ a * c`. -/
 
 
+#print lt_mul_of_one_lt_of_le_of_pos /-
 theorem lt_mul_of_one_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b ≤ c) (hc : 0 < c) :
     b < a * c :=
   h.trans_lt <| lt_mul_of_one_lt_left hc ha
 #align lt_mul_of_one_lt_of_le_of_pos lt_mul_of_one_lt_of_le_of_pos
+-/
 
+#print lt_mul_of_one_le_of_lt_of_nonneg /-
 theorem lt_mul_of_one_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b < c) (hc : 0 ≤ c) :
     b < a * c :=
   h.trans_le <| le_mul_of_one_le_left hc ha
 #align lt_mul_of_one_le_of_lt_of_nonneg lt_mul_of_one_le_of_lt_of_nonneg
+-/
 
+#print lt_mul_of_one_lt_of_lt_of_pos /-
 theorem lt_mul_of_one_lt_of_lt_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b < c) (hc : 0 < c) :
     b < a * c :=
   h.trans <| lt_mul_of_one_lt_left hc ha
 #align lt_mul_of_one_lt_of_lt_of_pos lt_mul_of_one_lt_of_lt_of_pos
+-/
 
+#print Right.one_lt_mul_of_lt_of_le_of_pos /-
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (hb : 1 ≤ b)
     (b0 : 0 < b) : 1 < a * b :=
   lt_mul_of_one_lt_of_le_of_pos ha hb b0
 #align right.one_lt_mul_of_lt_of_le_of_pos Right.one_lt_mul_of_lt_of_le_of_pos
+-/
 
+#print Right.one_lt_mul_of_le_of_lt_of_nonneg /-
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (hb : 1 < b)
     (b0 : 0 ≤ b) : 1 < a * b :=
   lt_mul_of_one_le_of_lt_of_nonneg ha hb b0
 #align right.one_lt_mul_of_le_of_lt_of_nonneg Right.one_lt_mul_of_le_of_lt_of_nonneg
+-/
 
+#print Right.one_lt_mul_of_lt_of_lt /-
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_lt_of_lt [MulPosStrictMono α] (ha : 1 < a) (hb : 1 < b) (b0 : 0 < b) :
     1 < a * b :=
   lt_mul_of_one_lt_of_lt_of_pos ha hb b0
 #align right.one_lt_mul_of_lt_of_lt Right.one_lt_mul_of_lt_of_lt
+-/
 
+#print lt_mul_of_one_lt_of_lt_of_nonneg /-
 theorem lt_mul_of_one_lt_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b < c) (hc : 0 ≤ c) :
     b < a * c :=
   h.trans_le <| le_mul_of_one_le_left hc ha
 #align lt_mul_of_one_lt_of_lt_of_nonneg lt_mul_of_one_lt_of_lt_of_nonneg
+-/
 
+#print lt_of_mul_lt_of_one_le_of_nonneg_left /-
 theorem lt_of_mul_lt_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b < c) (hle : 1 ≤ b)
     (ha : 0 ≤ a) : a < c :=
   (le_mul_of_one_le_right ha hle).trans_lt h
 #align lt_of_mul_lt_of_one_le_of_nonneg_left lt_of_mul_lt_of_one_le_of_nonneg_left
+-/
 
+#print lt_of_lt_mul_of_le_one_of_nonneg_left /-
 theorem lt_of_lt_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a < b * c) (hc : c ≤ 1)
     (hb : 0 ≤ b) : a < b :=
   h.trans_le <| mul_le_of_le_one_right hb hc
 #align lt_of_lt_mul_of_le_one_of_nonneg_left lt_of_lt_mul_of_le_one_of_nonneg_left
+-/
 
+#print lt_of_lt_mul_of_le_one_of_nonneg_right /-
 theorem lt_of_lt_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a < b * c) (hb : b ≤ 1)
     (hc : 0 ≤ c) : a < c :=
   h.trans_le <| mul_le_of_le_one_left hc hb
 #align lt_of_lt_mul_of_le_one_of_nonneg_right lt_of_lt_mul_of_le_one_of_nonneg_right
+-/
 
+#print le_mul_of_one_le_of_le_of_nonneg /-
 theorem le_mul_of_one_le_of_le_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (bc : b ≤ c) (c0 : 0 ≤ c) :
     b ≤ a * c :=
   bc.trans <| le_mul_of_one_le_left c0 ha
 #align le_mul_of_one_le_of_le_of_nonneg le_mul_of_one_le_of_le_of_nonneg
+-/
 
+#print Right.one_le_mul_of_le_of_le /-
 /-- Assumes right covariance. -/
 theorem Right.one_le_mul_of_le_of_le [MulPosMono α] (ha : 1 ≤ a) (hb : 1 ≤ b) (b0 : 0 ≤ b) :
     1 ≤ a * b :=
   le_mul_of_one_le_of_le_of_nonneg ha hb b0
 #align right.one_le_mul_of_le_of_le Right.one_le_mul_of_le_of_le
+-/
 
+#print le_of_mul_le_of_one_le_of_nonneg_left /-
 theorem le_of_mul_le_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hb : 1 ≤ b)
     (ha : 0 ≤ a) : a ≤ c :=
   (le_mul_of_one_le_right ha hb).trans h
 #align le_of_mul_le_of_one_le_of_nonneg_left le_of_mul_le_of_one_le_of_nonneg_left
+-/
 
+#print le_of_le_mul_of_le_one_of_nonneg_left /-
 theorem le_of_le_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a ≤ b * c) (hc : c ≤ 1)
     (hb : 0 ≤ b) : a ≤ b :=
   h.trans <| mul_le_of_le_one_right hb hc
 #align le_of_le_mul_of_le_one_of_nonneg_left le_of_le_mul_of_le_one_of_nonneg_left
+-/
 
+#print le_of_mul_le_of_one_le_nonneg_right /-
 theorem le_of_mul_le_of_one_le_nonneg_right [MulPosMono α] (h : a * b ≤ c) (ha : 1 ≤ a)
     (hb : 0 ≤ b) : b ≤ c :=
   (le_mul_of_one_le_left hb ha).trans h
 #align le_of_mul_le_of_one_le_nonneg_right le_of_mul_le_of_one_le_nonneg_right
+-/
 
+#print le_of_le_mul_of_le_one_of_nonneg_right /-
 theorem le_of_le_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a ≤ b * c) (hb : b ≤ 1)
     (hc : 0 ≤ c) : a ≤ c :=
   h.trans <| mul_le_of_le_one_left hc hb
 #align le_of_le_mul_of_le_one_of_nonneg_right le_of_le_mul_of_le_one_of_nonneg_right
+-/
 
 end Preorder
 
@@ -1039,6 +1241,7 @@ section LinearOrder
 
 variable [LinearOrder α]
 
+#print exists_square_le' /-
 -- Yaël: What's the point of this lemma? If we have `0 * 0 = 0`, then we can just take `b = 0`.
 -- proven with `a0 : 0 ≤ a` as `exists_square_le`
 theorem exists_square_le' [PosMulStrictMono α] (a0 : 0 < a) : ∃ b : α, b * b ≤ a :=
@@ -1047,6 +1250,7 @@ theorem exists_square_le' [PosMulStrictMono α] (a0 : 0 < a) : ∃ b : α, b * b
   · exact ⟨a, (mul_lt_of_lt_one_right a0 ha).le⟩
   · exact ⟨1, by rwa [mul_one]⟩
 #align exists_square_le' exists_square_le'
+-/
 
 end LinearOrder
 
@@ -1060,43 +1264,59 @@ section PartialOrder
 
 variable [PartialOrder α]
 
+#print PosMulMono.toPosMulStrictMono /-
 theorem PosMulMono.toPosMulStrictMono [PosMulMono α] : PosMulStrictMono α :=
   ⟨fun x a b h =>
     (mul_le_mul_of_nonneg_left h.le x.2.le).lt_of_ne (h.Ne ∘ mul_left_cancel₀ x.2.ne')⟩
 #align pos_mul_mono.to_pos_mul_strict_mono PosMulMono.toPosMulStrictMono
+-/
 
+#print posMulMono_iff_posMulStrictMono /-
 theorem posMulMono_iff_posMulStrictMono : PosMulMono α ↔ PosMulStrictMono α :=
   ⟨@PosMulMono.toPosMulStrictMono α _ _, @PosMulStrictMono.toPosMulMono α _ _⟩
 #align pos_mul_mono_iff_pos_mul_strict_mono posMulMono_iff_posMulStrictMono
+-/
 
+#print MulPosMono.toMulPosStrictMono /-
 theorem MulPosMono.toMulPosStrictMono [MulPosMono α] : MulPosStrictMono α :=
   ⟨fun x a b h =>
     (mul_le_mul_of_nonneg_right h.le x.2.le).lt_of_ne (h.Ne ∘ mul_right_cancel₀ x.2.ne')⟩
 #align mul_pos_mono.to_mul_pos_strict_mono MulPosMono.toMulPosStrictMono
+-/
 
+#print mulPosMono_iff_mulPosStrictMono /-
 theorem mulPosMono_iff_mulPosStrictMono : MulPosMono α ↔ MulPosStrictMono α :=
   ⟨@MulPosMono.toMulPosStrictMono α _ _, @MulPosStrictMono.toMulPosMono α _ _⟩
 #align mul_pos_mono_iff_mul_pos_strict_mono mulPosMono_iff_mulPosStrictMono
+-/
 
+#print PosMulReflectLT.toPosMulMonoRev /-
 theorem PosMulReflectLT.toPosMulMonoRev [PosMulReflectLT α] : PosMulMonoRev α :=
   ⟨fun x a b h =>
     h.eq_or_lt.elim (le_of_eq ∘ mul_left_cancel₀ x.2.Ne.symm) fun h' =>
       (lt_of_mul_lt_mul_left h' x.2.le).le⟩
 #align pos_mul_reflect_lt.to_pos_mul_mono_rev PosMulReflectLT.toPosMulMonoRev
+-/
 
+#print posMulMonoRev_iff_posMulReflectLT /-
 theorem posMulMonoRev_iff_posMulReflectLT : PosMulMonoRev α ↔ PosMulReflectLT α :=
   ⟨@PosMulMonoRev.toPosMulReflectLT α _ _, @PosMulReflectLT.toPosMulMonoRev α _ _⟩
 #align pos_mul_mono_rev_iff_pos_mul_reflect_lt posMulMonoRev_iff_posMulReflectLT
+-/
 
+#print MulPosReflectLT.toMulPosMonoRev /-
 theorem MulPosReflectLT.toMulPosMonoRev [MulPosReflectLT α] : MulPosMonoRev α :=
   ⟨fun x a b h =>
     h.eq_or_lt.elim (le_of_eq ∘ mul_right_cancel₀ x.2.Ne.symm) fun h' =>
       (lt_of_mul_lt_mul_right h' x.2.le).le⟩
 #align mul_pos_reflect_lt.to_mul_pos_mono_rev MulPosReflectLT.toMulPosMonoRev
+-/
 
+#print mulPosMonoRev_iff_mulPosReflectLT /-
 theorem mulPosMonoRev_iff_mulPosReflectLT : MulPosMonoRev α ↔ MulPosReflectLT α :=
   ⟨@MulPosMonoRev.toMulPosReflectLT α _ _, @MulPosReflectLT.toMulPosMonoRev α _ _⟩
 #align mul_pos_mono_rev_iff_mul_pos_reflect_lt mulPosMonoRev_iff_mulPosReflectLT
+-/
 
 end PartialOrder
 
@@ -1106,20 +1326,28 @@ section CommSemigroupHasZero
 
 variable [CommSemigroup α] [Zero α] [Preorder α]
 
+#print posMulStrictMono_iff_mulPosStrictMono /-
 theorem posMulStrictMono_iff_mulPosStrictMono : PosMulStrictMono α ↔ MulPosStrictMono α := by
   simp! only [mul_comm]
 #align pos_mul_strict_mono_iff_mul_pos_strict_mono posMulStrictMono_iff_mulPosStrictMono
+-/
 
+#print posMulReflectLT_iff_mulPosReflectLT /-
 theorem posMulReflectLT_iff_mulPosReflectLT : PosMulReflectLT α ↔ MulPosReflectLT α := by
   simp! only [mul_comm]
 #align pos_mul_reflect_lt_iff_mul_pos_reflect_lt posMulReflectLT_iff_mulPosReflectLT
+-/
 
+#print posMulMono_iff_mulPosMono /-
 theorem posMulMono_iff_mulPosMono : PosMulMono α ↔ MulPosMono α := by simp! only [mul_comm]
 #align pos_mul_mono_iff_mul_pos_mono posMulMono_iff_mulPosMono
+-/
 
+#print posMulMonoRev_iff_mulPosMonoRev /-
 theorem posMulMonoRev_iff_mulPosMonoRev : PosMulMonoRev α ↔ MulPosMonoRev α := by
   simp! only [mul_comm]
 #align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulMonoRev_iff_mulPosMonoRev
+-/
 
 end CommSemigroupHasZero

44e29dbc

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -640,7 +640,7 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
   rcases lt_trichotomy 0 a with (ha | rfl | ha)
   · refine' Or.inl ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonneg_of_nonpos ha.le hb
-  · rw [MulZeroClass.zero_mul] at hab; exact hab.false.elim
+  · rw [MulZeroClass.zero_mul] at hab ; exact hab.false.elim
   · refine' Or.inr ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonpos_of_nonneg ha.le hb
 #align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_pos

44e29dbc

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -147,57 +147,81 @@ section Preorder
 
 variable [Preorder α]
 
+#print PosMulMono.to_covariantClass_pos_mul_le /-
 instance PosMulMono.to_covariantClass_pos_mul_le [PosMulMono α] :
     CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
   ⟨fun a b c bc => @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.to_covariantClass_pos_mul_le
+-/
 
+#print MulPosMono.to_covariantClass_pos_mul_le /-
 instance MulPosMono.to_covariantClass_pos_mul_le [MulPosMono α] :
     CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
   ⟨fun a b c bc => @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.to_covariantClass_pos_mul_le
+-/
 
+#print PosMulReflectLT.to_contravariantClass_pos_mul_lt /-
 instance PosMulReflectLT.to_contravariantClass_pos_mul_lt [PosMulReflectLT α] :
     ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
   ⟨fun a b c bc => @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt PosMulReflectLT.to_contravariantClass_pos_mul_lt
+-/
 
+#print MulPosReflectLT.to_contravariantClass_pos_mul_lt /-
 instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
     ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
   ⟨fun a b c bc => @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_lt
+-/
 
+#print mul_le_mul_of_nonneg_left /-
 theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c :=
   @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_left mul_le_mul_of_nonneg_left
+-/
 
+#print mul_le_mul_of_nonneg_right /-
 theorem mul_le_mul_of_nonneg_right [MulPosMono α] (h : b ≤ c) (a0 : 0 ≤ a) : b * a ≤ c * a :=
   @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_right mul_le_mul_of_nonneg_right
+-/
 
+#print mul_lt_mul_of_pos_left /-
 theorem mul_lt_mul_of_pos_left [PosMulStrictMono α] (bc : b < c) (a0 : 0 < a) : a * b < a * c :=
   @CovariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_left mul_lt_mul_of_pos_left
+-/
 
+#print mul_lt_mul_of_pos_right /-
 theorem mul_lt_mul_of_pos_right [MulPosStrictMono α] (bc : b < c) (a0 : 0 < a) : b * a < c * a :=
   @CovariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_right mul_lt_mul_of_pos_right
+-/
 
+#print lt_of_mul_lt_mul_left /-
 theorem lt_of_mul_lt_mul_left [PosMulReflectLT α] (h : a * b < a * c) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ h
 #align lt_of_mul_lt_mul_left lt_of_mul_lt_mul_left
+-/
 
+#print lt_of_mul_lt_mul_right /-
 theorem lt_of_mul_lt_mul_right [MulPosReflectLT α] (h : b * a < c * a) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ h
 #align lt_of_mul_lt_mul_right lt_of_mul_lt_mul_right
+-/
 
+#print le_of_mul_le_mul_left /-
 theorem le_of_mul_le_mul_left [PosMulMonoRev α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_left le_of_mul_le_mul_left
+-/
 
+#print le_of_mul_le_mul_right /-
 theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_right le_of_mul_le_mul_right
+-/
 
 alias lt_of_mul_lt_mul_left ← lt_of_mul_lt_mul_of_nonneg_left
 #align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_left
@@ -211,77 +235,105 @@ alias le_of_mul_le_mul_left ← le_of_mul_le_mul_of_pos_left
 alias le_of_mul_le_mul_right ← le_of_mul_le_mul_of_pos_right
 #align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_right
 
+#print mul_lt_mul_left /-
 @[simp]
 theorem mul_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a * b < a * c ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· < ·) _ _ ⟨a, a0⟩ _ _
 #align mul_lt_mul_left mul_lt_mul_left
+-/
 
+#print mul_lt_mul_right /-
 @[simp]
 theorem mul_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a) :
     b * a < c * a ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· < ·) _ _ ⟨a, a0⟩ _ _
 #align mul_lt_mul_right mul_lt_mul_right
+-/
 
+#print mul_le_mul_left /-
 @[simp]
 theorem mul_le_mul_left [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_left mul_le_mul_left
+-/
 
+#print mul_le_mul_right /-
 @[simp]
 theorem mul_le_mul_right [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_right mul_le_mul_right
+-/
 
+#print mul_lt_mul_of_pos_of_nonneg /-
 theorem mul_lt_mul_of_pos_of_nonneg [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 ≤ d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans_le (mul_le_mul_of_nonneg_right h₁ d0)
 #align mul_lt_mul_of_pos_of_nonneg mul_lt_mul_of_pos_of_nonneg
+-/
 
+#print mul_lt_mul_of_le_of_le' /-
 theorem mul_lt_mul_of_le_of_le' [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 ≤ c) : a * c < b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans_lt (mul_lt_mul_of_pos_left h₂ b0)
 #align mul_lt_mul_of_le_of_le' mul_lt_mul_of_le_of_le'
+-/
 
+#print mul_lt_mul_of_nonneg_of_pos /-
 theorem mul_lt_mul_of_nonneg_of_pos [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (a0 : 0 ≤ a) (d0 : 0 < d) : a * c < b * d :=
   (mul_le_mul_of_nonneg_left h₂ a0).trans_lt (mul_lt_mul_of_pos_right h₁ d0)
 #align mul_lt_mul_of_nonneg_of_pos mul_lt_mul_of_nonneg_of_pos
+-/
 
+#print mul_lt_mul_of_le_of_lt' /-
 theorem mul_lt_mul_of_le_of_lt' [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (b0 : 0 ≤ b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans_le (mul_le_mul_of_nonneg_left h₂ b0)
 #align mul_lt_mul_of_le_of_lt' mul_lt_mul_of_le_of_lt'
+-/
 
+#print mul_lt_mul_of_pos_of_pos /-
 theorem mul_lt_mul_of_pos_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 < d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans (mul_lt_mul_of_pos_right h₁ d0)
 #align mul_lt_mul_of_pos_of_pos mul_lt_mul_of_pos_of_pos
+-/
 
+#print mul_lt_mul_of_lt_of_lt' /-
 theorem mul_lt_mul_of_lt_of_lt' [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans (mul_lt_mul_of_pos_left h₂ b0)
 #align mul_lt_mul_of_lt_of_lt' mul_lt_mul_of_lt_of_lt'
+-/
 
+#print mul_lt_of_mul_lt_of_nonneg_left /-
 theorem mul_lt_of_mul_lt_of_nonneg_left [PosMulMono α] (h : a * b < c) (hdb : d ≤ b) (ha : 0 ≤ a) :
     a * d < c :=
   (mul_le_mul_of_nonneg_left hdb ha).trans_lt h
 #align mul_lt_of_mul_lt_of_nonneg_left mul_lt_of_mul_lt_of_nonneg_left
+-/
 
+#print lt_mul_of_lt_mul_of_nonneg_left /-
 theorem lt_mul_of_lt_mul_of_nonneg_left [PosMulMono α] (h : a < b * c) (hcd : c ≤ d) (hb : 0 ≤ b) :
     a < b * d :=
   h.trans_le <| mul_le_mul_of_nonneg_left hcd hb
 #align lt_mul_of_lt_mul_of_nonneg_left lt_mul_of_lt_mul_of_nonneg_left
+-/
 
+#print mul_lt_of_mul_lt_of_nonneg_right /-
 theorem mul_lt_of_mul_lt_of_nonneg_right [MulPosMono α] (h : a * b < c) (hda : d ≤ a) (hb : 0 ≤ b) :
     d * b < c :=
   (mul_le_mul_of_nonneg_right hda hb).trans_lt h
 #align mul_lt_of_mul_lt_of_nonneg_right mul_lt_of_mul_lt_of_nonneg_right
+-/
 
+#print lt_mul_of_lt_mul_of_nonneg_right /-
 theorem lt_mul_of_lt_mul_of_nonneg_right [MulPosMono α] (h : a < b * c) (hbd : b ≤ d) (hc : 0 ≤ c) :
     a < d * c :=
   h.trans_le <| mul_le_mul_of_nonneg_right hbd hc
 #align lt_mul_of_lt_mul_of_nonneg_right lt_mul_of_lt_mul_of_nonneg_right
+-/
 
 end Preorder

44e29dbc

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -147,317 +147,137 @@ section Preorder
 
 variable [Preorder α]
 
-/- warning: pos_mul_mono.to_covariant_class_pos_mul_le -> PosMulMono.to_covariantClass_pos_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x) y) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.992 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.992) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1023 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1023)
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.to_covariantClass_pos_mul_leₓ'. -/
 instance PosMulMono.to_covariantClass_pos_mul_le [PosMulMono α] :
     CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
   ⟨fun a b c bc => @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.to_covariantClass_pos_mul_le
 
-/- warning: mul_pos_mono.to_covariant_class_pos_mul_le -> MulPosMono.to_covariantClass_pos_mul_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1118 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1118) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1149 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1149)
-Case conversion may be inaccurate. Consider using '#align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.to_covariantClass_pos_mul_leₓ'. -/
 instance MulPosMono.to_covariantClass_pos_mul_le [MulPosMono α] :
     CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
   ⟨fun a b c bc => @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.to_covariantClass_pos_mul_le
 
-/- warning: pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt -> PosMulReflectLT.to_contravariantClass_pos_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x) y) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1244 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1244) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1275 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1275)
-Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt PosMulReflectLT.to_contravariantClass_pos_mul_ltₓ'. -/
 instance PosMulReflectLT.to_contravariantClass_pos_mul_lt [PosMulReflectLT α] :
     ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
   ⟨fun a b c bc => @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt PosMulReflectLT.to_contravariantClass_pos_mul_lt
 
-/- warning: mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt -> MulPosReflectLT.to_contravariantClass_pos_mul_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1370 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1370) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1401 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1401)
-Case conversion may be inaccurate. Consider using '#align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_ltₓ'. -/
 instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
     ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
   ⟨fun a b c bc => @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_lt
 
-/- warning: mul_le_mul_of_nonneg_left -> mul_le_mul_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
-Case conversion may be inaccurate. Consider using '#align mul_le_mul_of_nonneg_left mul_le_mul_of_nonneg_leftₓ'. -/
 theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c :=
   @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_left mul_le_mul_of_nonneg_left
 
-/- warning: mul_le_mul_of_nonneg_right -> mul_le_mul_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
-Case conversion may be inaccurate. Consider using '#align mul_le_mul_of_nonneg_right mul_le_mul_of_nonneg_rightₓ'. -/
 theorem mul_le_mul_of_nonneg_right [MulPosMono α] (h : b ≤ c) (a0 : 0 ≤ a) : b * a ≤ c * a :=
   @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_right mul_le_mul_of_nonneg_right
 
-/- warning: mul_lt_mul_of_pos_left -> mul_lt_mul_of_pos_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_left mul_lt_mul_of_pos_leftₓ'. -/
 theorem mul_lt_mul_of_pos_left [PosMulStrictMono α] (bc : b < c) (a0 : 0 < a) : a * b < a * c :=
   @CovariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_left mul_lt_mul_of_pos_left
 
-/- warning: mul_lt_mul_of_pos_right -> mul_lt_mul_of_pos_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_right mul_lt_mul_of_pos_rightₓ'. -/
 theorem mul_lt_mul_of_pos_right [MulPosStrictMono α] (bc : b < c) (a0 : 0 < a) : b * a < c * a :=
   @CovariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_right mul_lt_mul_of_pos_right
 
-/- warning: lt_of_mul_lt_mul_left -> lt_of_mul_lt_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_left lt_of_mul_lt_mul_leftₓ'. -/
 theorem lt_of_mul_lt_mul_left [PosMulReflectLT α] (h : a * b < a * c) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ h
 #align lt_of_mul_lt_mul_left lt_of_mul_lt_mul_left
 
-/- warning: lt_of_mul_lt_mul_right -> lt_of_mul_lt_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_right lt_of_mul_lt_mul_rightₓ'. -/
 theorem lt_of_mul_lt_mul_right [MulPosReflectLT α] (h : b * a < c * a) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ h
 #align lt_of_mul_lt_mul_right lt_of_mul_lt_mul_right
 
-/- warning: le_of_mul_le_mul_left -> le_of_mul_le_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_left le_of_mul_le_mul_leftₓ'. -/
 theorem le_of_mul_le_mul_left [PosMulMonoRev α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_left le_of_mul_le_mul_left
 
-/- warning: le_of_mul_le_mul_right -> le_of_mul_le_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_right le_of_mul_le_mul_rightₓ'. -/
 theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_right le_of_mul_le_mul_right
 
-/- warning: lt_of_mul_lt_mul_of_nonneg_left -> lt_of_mul_lt_mul_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_leftₓ'. -/
 alias lt_of_mul_lt_mul_left ← lt_of_mul_lt_mul_of_nonneg_left
 #align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_left
 
-/- warning: lt_of_mul_lt_mul_of_nonneg_right -> lt_of_mul_lt_mul_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_of_nonneg_right lt_of_mul_lt_mul_of_nonneg_rightₓ'. -/
 alias lt_of_mul_lt_mul_right ← lt_of_mul_lt_mul_of_nonneg_right
 #align lt_of_mul_lt_mul_of_nonneg_right lt_of_mul_lt_mul_of_nonneg_right
 
-/- warning: le_of_mul_le_mul_of_pos_left -> le_of_mul_le_mul_of_pos_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_of_pos_left le_of_mul_le_mul_of_pos_leftₓ'. -/
 alias le_of_mul_le_mul_left ← le_of_mul_le_mul_of_pos_left
 #align le_of_mul_le_mul_of_pos_left le_of_mul_le_mul_of_pos_left
 
-/- warning: le_of_mul_le_mul_of_pos_right -> le_of_mul_le_mul_of_pos_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_rightₓ'. -/
 alias le_of_mul_le_mul_right ← le_of_mul_le_mul_of_pos_right
 #align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_right
 
-/- warning: mul_lt_mul_left -> mul_lt_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_left mul_lt_mul_leftₓ'. -/
 @[simp]
 theorem mul_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a * b < a * c ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· < ·) _ _ ⟨a, a0⟩ _ _
 #align mul_lt_mul_left mul_lt_mul_left
 
-/- warning: mul_lt_mul_right -> mul_lt_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_right mul_lt_mul_rightₓ'. -/
 @[simp]
 theorem mul_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a) :
     b * a < c * a ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· < ·) _ _ ⟨a, a0⟩ _ _
 #align mul_lt_mul_right mul_lt_mul_right
 
-/- warning: mul_le_mul_left -> mul_le_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align mul_le_mul_left mul_le_mul_leftₓ'. -/
 @[simp]
 theorem mul_le_mul_left [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_left mul_le_mul_left
 
-/- warning: mul_le_mul_right -> mul_le_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c))
-Case conversion may be inaccurate. Consider using '#align mul_le_mul_right mul_le_mul_rightₓ'. -/
 @[simp]
 theorem mul_le_mul_right [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_right mul_le_mul_right
 
-/- warning: mul_lt_mul_of_pos_of_nonneg -> mul_lt_mul_of_pos_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_of_nonneg mul_lt_mul_of_pos_of_nonnegₓ'. -/
 theorem mul_lt_mul_of_pos_of_nonneg [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 ≤ d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans_le (mul_le_mul_of_nonneg_right h₁ d0)
 #align mul_lt_mul_of_pos_of_nonneg mul_lt_mul_of_pos_of_nonneg
 
-/- warning: mul_lt_mul_of_le_of_le' -> mul_lt_mul_of_le_of_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_le_of_le' mul_lt_mul_of_le_of_le'ₓ'. -/
 theorem mul_lt_mul_of_le_of_le' [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 ≤ c) : a * c < b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans_lt (mul_lt_mul_of_pos_left h₂ b0)
 #align mul_lt_mul_of_le_of_le' mul_lt_mul_of_le_of_le'
 
-/- warning: mul_lt_mul_of_nonneg_of_pos -> mul_lt_mul_of_nonneg_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_nonneg_of_pos mul_lt_mul_of_nonneg_of_posₓ'. -/
 theorem mul_lt_mul_of_nonneg_of_pos [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (a0 : 0 ≤ a) (d0 : 0 < d) : a * c < b * d :=
   (mul_le_mul_of_nonneg_left h₂ a0).trans_lt (mul_lt_mul_of_pos_right h₁ d0)
 #align mul_lt_mul_of_nonneg_of_pos mul_lt_mul_of_nonneg_of_pos
 
-/- warning: mul_lt_mul_of_le_of_lt' -> mul_lt_mul_of_le_of_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_le_of_lt' mul_lt_mul_of_le_of_lt'ₓ'. -/
 theorem mul_lt_mul_of_le_of_lt' [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (b0 : 0 ≤ b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans_le (mul_le_mul_of_nonneg_left h₂ b0)
 #align mul_lt_mul_of_le_of_lt' mul_lt_mul_of_le_of_lt'
 
-/- warning: mul_lt_mul_of_pos_of_pos -> mul_lt_mul_of_pos_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_of_pos mul_lt_mul_of_pos_of_posₓ'. -/
 theorem mul_lt_mul_of_pos_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 < d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans (mul_lt_mul_of_pos_right h₁ d0)
 #align mul_lt_mul_of_pos_of_pos mul_lt_mul_of_pos_of_pos
 
-/- warning: mul_lt_mul_of_lt_of_lt' -> mul_lt_mul_of_lt_of_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_lt_of_lt' mul_lt_mul_of_lt_of_lt'ₓ'. -/
 theorem mul_lt_mul_of_lt_of_lt' [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans (mul_lt_mul_of_pos_left h₂ b0)
 #align mul_lt_mul_of_lt_of_lt' mul_lt_mul_of_lt_of_lt'
 
-/- warning: mul_lt_of_mul_lt_of_nonneg_left -> mul_lt_of_mul_lt_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) d b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a d) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) d b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a d) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_mul_lt_of_nonneg_left mul_lt_of_mul_lt_of_nonneg_leftₓ'. -/
 theorem mul_lt_of_mul_lt_of_nonneg_left [PosMulMono α] (h : a * b < c) (hdb : d ≤ b) (ha : 0 ≤ a) :
     a * d < c :=
   (mul_le_mul_of_nonneg_left hdb ha).trans_lt h
 #align mul_lt_of_mul_lt_of_nonneg_left mul_lt_of_mul_lt_of_nonneg_left
 
-/- warning: lt_mul_of_lt_mul_of_nonneg_left -> lt_mul_of_lt_mul_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_mul_of_nonneg_left lt_mul_of_lt_mul_of_nonneg_leftₓ'. -/
 theorem lt_mul_of_lt_mul_of_nonneg_left [PosMulMono α] (h : a < b * c) (hcd : c ≤ d) (hb : 0 ≤ b) :
     a < b * d :=
   h.trans_le <| mul_le_mul_of_nonneg_left hcd hb
 #align lt_mul_of_lt_mul_of_nonneg_left lt_mul_of_lt_mul_of_nonneg_left
 
-/- warning: mul_lt_of_mul_lt_of_nonneg_right -> mul_lt_of_mul_lt_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) d a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) d a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d b) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_mul_lt_of_nonneg_right mul_lt_of_mul_lt_of_nonneg_rightₓ'. -/
 theorem mul_lt_of_mul_lt_of_nonneg_right [MulPosMono α] (h : a * b < c) (hda : d ≤ a) (hb : 0 ≤ b) :
     d * b < c :=
   (mul_le_mul_of_nonneg_right hda hb).trans_lt h
 #align mul_lt_of_mul_lt_of_nonneg_right mul_lt_of_mul_lt_of_nonneg_right
 
-/- warning: lt_mul_of_lt_mul_of_nonneg_right -> lt_mul_of_lt_mul_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d c))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_mul_of_nonneg_right lt_mul_of_lt_mul_of_nonneg_rightₓ'. -/
 theorem lt_mul_of_lt_mul_of_nonneg_right [MulPosMono α] (h : a < b * c) (hbd : b ≤ d) (hc : 0 ≤ c) :
     a < d * c :=
   h.trans_le <| mul_le_mul_of_nonneg_right hbd hc
@@ -553,233 +373,101 @@ section Preorder
 
 variable [Preorder α]
 
-/- warning: left.mul_pos -> Left.mul_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align left.mul_pos Left.mul_posₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.mul_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
   simpa only [MulZeroClass.mul_zero] using mul_lt_mul_of_pos_left hb ha
 #align left.mul_pos Left.mul_pos
 
-/- warning: mul_pos -> mul_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align mul_pos mul_posₓ'. -/
 alias Left.mul_pos ← mul_pos
 #align mul_pos mul_pos
 
-/- warning: mul_neg_of_pos_of_neg -> mul_neg_of_pos_of_neg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mul_neg_of_pos_of_neg mul_neg_of_pos_of_negₓ'. -/
 theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) : a * b < 0 := by
   simpa only [MulZeroClass.mul_zero] using mul_lt_mul_of_pos_left hb ha
 #align mul_neg_of_pos_of_neg mul_neg_of_pos_of_neg
 
-/- warning: zero_lt_mul_left -> zero_lt_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) c b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) c b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b))
-Case conversion may be inaccurate. Consider using '#align zero_lt_mul_left zero_lt_mul_leftₓ'. -/
 @[simp]
 theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) : 0 < c * b ↔ 0 < b :=
   by convert mul_lt_mul_left h; simp
 #align zero_lt_mul_left zero_lt_mul_left
 
-/- warning: right.mul_pos -> Right.mul_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align right.mul_pos Right.mul_posₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.mul_pos [MulPosStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
   simpa only [MulZeroClass.zero_mul] using mul_lt_mul_of_pos_right ha hb
 #align right.mul_pos Right.mul_pos
 
-/- warning: mul_neg_of_neg_of_pos -> mul_neg_of_neg_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mul_neg_of_neg_of_pos mul_neg_of_neg_of_posₓ'. -/
 theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) : a * b < 0 := by
   simpa only [MulZeroClass.zero_mul] using mul_lt_mul_of_pos_right ha hb
 #align mul_neg_of_neg_of_pos mul_neg_of_neg_of_pos
 
-/- warning: zero_lt_mul_right -> zero_lt_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b))
-Case conversion may be inaccurate. Consider using '#align zero_lt_mul_right zero_lt_mul_rightₓ'. -/
 @[simp]
 theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
     0 < b * c ↔ 0 < b := by convert mul_lt_mul_right h; simp
 #align zero_lt_mul_right zero_lt_mul_right
 
-/- warning: left.mul_nonneg -> Left.mul_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align left.mul_nonneg Left.mul_nonnegₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
   simpa only [MulZeroClass.mul_zero] using mul_le_mul_of_nonneg_left hb ha
 #align left.mul_nonneg Left.mul_nonneg
 
-/- warning: mul_nonneg -> mul_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align mul_nonneg mul_nonnegₓ'. -/
 alias Left.mul_nonneg ← mul_nonneg
 #align mul_nonneg mul_nonneg
 
-/- warning: mul_nonpos_of_nonneg_of_nonpos -> mul_nonpos_of_nonneg_of_nonpos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mul_nonpos_of_nonneg_of_nonpos mul_nonpos_of_nonneg_of_nonposₓ'. -/
 theorem mul_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0 := by
   simpa only [MulZeroClass.mul_zero] using mul_le_mul_of_nonneg_left hb ha
 #align mul_nonpos_of_nonneg_of_nonpos mul_nonpos_of_nonneg_of_nonpos
 
-/- warning: right.mul_nonneg -> Right.mul_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align right.mul_nonneg Right.mul_nonnegₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.mul_nonneg [MulPosMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
   simpa only [MulZeroClass.zero_mul] using mul_le_mul_of_nonneg_right ha hb
 #align right.mul_nonneg Right.mul_nonneg
 
-/- warning: mul_nonpos_of_nonpos_of_nonneg -> mul_nonpos_of_nonpos_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align mul_nonpos_of_nonpos_of_nonneg mul_nonpos_of_nonpos_of_nonnegₓ'. -/
 theorem mul_nonpos_of_nonpos_of_nonneg [MulPosMono α] (ha : a ≤ 0) (hb : 0 ≤ b) : a * b ≤ 0 := by
   simpa only [MulZeroClass.zero_mul] using mul_le_mul_of_nonneg_right ha hb
 #align mul_nonpos_of_nonpos_of_nonneg mul_nonpos_of_nonpos_of_nonneg
 
-/- warning: pos_of_mul_pos_right -> pos_of_mul_pos_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b)
-Case conversion may be inaccurate. Consider using '#align pos_of_mul_pos_right pos_of_mul_pos_rightₓ'. -/
 theorem pos_of_mul_pos_right [PosMulReflectLT α] (h : 0 < a * b) (ha : 0 ≤ a) : 0 < b :=
   lt_of_mul_lt_mul_left ((MulZeroClass.mul_zero a).symm ▸ h : a * 0 < a * b) ha
 #align pos_of_mul_pos_right pos_of_mul_pos_right
 
-/- warning: pos_of_mul_pos_left -> pos_of_mul_pos_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a)
-Case conversion may be inaccurate. Consider using '#align pos_of_mul_pos_left pos_of_mul_pos_leftₓ'. -/
 theorem pos_of_mul_pos_left [MulPosReflectLT α] (h : 0 < a * b) (hb : 0 ≤ b) : 0 < a :=
   lt_of_mul_lt_mul_right ((MulZeroClass.zero_mul b).symm ▸ h : 0 * b < a * b) hb
 #align pos_of_mul_pos_left pos_of_mul_pos_left
 
-/- warning: pos_iff_pos_of_mul_pos -> pos_iff_pos_of_mul_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b))
-Case conversion may be inaccurate. Consider using '#align pos_iff_pos_of_mul_pos pos_iff_pos_of_mul_posₓ'. -/
 theorem pos_iff_pos_of_mul_pos [PosMulReflectLT α] [MulPosReflectLT α] (hab : 0 < a * b) :
     0 < a ↔ 0 < b :=
   ⟨pos_of_mul_pos_right hab ∘ le_of_lt, pos_of_mul_pos_left hab ∘ le_of_lt⟩
 #align pos_iff_pos_of_mul_pos pos_iff_pos_of_mul_pos
 
-/- warning: mul_le_mul_of_le_of_le -> mul_le_mul_of_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d))
-Case conversion may be inaccurate. Consider using '#align mul_le_mul_of_le_of_le mul_le_mul_of_le_of_leₓ'. -/
 theorem mul_le_mul_of_le_of_le [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (a0 : 0 ≤ a)
     (d0 : 0 ≤ d) : a * c ≤ b * d :=
   (mul_le_mul_of_nonneg_left h₂ a0).trans <| mul_le_mul_of_nonneg_right h₁ d0
 #align mul_le_mul_of_le_of_le mul_le_mul_of_le_of_le
 
-/- warning: mul_le_mul -> mul_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d))
-Case conversion may be inaccurate. Consider using '#align mul_le_mul mul_le_mulₓ'. -/
 theorem mul_le_mul [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (c0 : 0 ≤ c)
     (b0 : 0 ≤ b) : a * c ≤ b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans <| mul_le_mul_of_nonneg_left h₂ b0
 #align mul_le_mul mul_le_mul
 
-/- warning: mul_self_le_mul_self -> mul_self_le_mul_self is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b b))
-Case conversion may be inaccurate. Consider using '#align mul_self_le_mul_self mul_self_le_mul_selfₓ'. -/
 theorem mul_self_le_mul_self [PosMulMono α] [MulPosMono α] (ha : 0 ≤ a) (hab : a ≤ b) :
     a * a ≤ b * b :=
   mul_le_mul hab hab ha <| ha.trans hab
 #align mul_self_le_mul_self mul_self_le_mul_self
 
-/- warning: mul_le_of_mul_le_of_nonneg_left -> mul_le_of_mul_le_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) d b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a d) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) d b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a d) c)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_mul_le_of_nonneg_left mul_le_of_mul_le_of_nonneg_leftₓ'. -/
 theorem mul_le_of_mul_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hle : d ≤ b) (a0 : 0 ≤ a) :
     a * d ≤ c :=
   (mul_le_mul_of_nonneg_left hle a0).trans h
 #align mul_le_of_mul_le_of_nonneg_left mul_le_of_mul_le_of_nonneg_left
 
-/- warning: le_mul_of_le_mul_of_nonneg_left -> le_mul_of_le_mul_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d))
-Case conversion may be inaccurate. Consider using '#align le_mul_of_le_mul_of_nonneg_left le_mul_of_le_mul_of_nonneg_leftₓ'. -/
 theorem le_mul_of_le_mul_of_nonneg_left [PosMulMono α] (h : a ≤ b * c) (hle : c ≤ d) (b0 : 0 ≤ b) :
     a ≤ b * d :=
   h.trans (mul_le_mul_of_nonneg_left hle b0)
 #align le_mul_of_le_mul_of_nonneg_left le_mul_of_le_mul_of_nonneg_left
 
-/- warning: mul_le_of_mul_le_of_nonneg_right -> mul_le_of_mul_le_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) d a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) d b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) d a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) d b) c)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_mul_le_of_nonneg_right mul_le_of_mul_le_of_nonneg_rightₓ'. -/
 theorem mul_le_of_mul_le_of_nonneg_right [MulPosMono α] (h : a * b ≤ c) (hle : d ≤ a) (b0 : 0 ≤ b) :
     d * b ≤ c :=
   (mul_le_mul_of_nonneg_right hle b0).trans h
 #align mul_le_of_mul_le_of_nonneg_right mul_le_of_mul_le_of_nonneg_right
 
-/- warning: le_mul_of_le_mul_of_nonneg_right -> le_mul_of_le_mul_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) b d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) d c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) b d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) d c))
-Case conversion may be inaccurate. Consider using '#align le_mul_of_le_mul_of_nonneg_right le_mul_of_le_mul_of_nonneg_rightₓ'. -/
 theorem le_mul_of_le_mul_of_nonneg_right [MulPosMono α] (h : a ≤ b * c) (hle : b ≤ d) (c0 : 0 ≤ c) :
     a ≤ d * c :=
   h.trans (mul_le_mul_of_nonneg_right hle c0)
@@ -791,12 +479,6 @@ section PartialOrder
 
 variable [PartialOrder α]
 
-/- warning: pos_mul_mono_iff_covariant_pos -> posMulMono_iff_covariant_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4707 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4707) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4738 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4738))
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono_iff_covariant_pos posMulMono_iff_covariant_posₓ'. -/
 theorem posMulMono_iff_covariant_pos :
     PosMulMono α ↔ CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
   ⟨@PosMulMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
@@ -806,12 +488,6 @@ theorem posMulMono_iff_covariant_pos :
       · exact @CovariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align pos_mul_mono_iff_covariant_pos posMulMono_iff_covariant_pos
 
-/- warning: mul_pos_mono_iff_covariant_pos -> mulPosMono_iff_covariant_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4845 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4845) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4876 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4876))
-Case conversion may be inaccurate. Consider using '#align mul_pos_mono_iff_covariant_pos mulPosMono_iff_covariant_posₓ'. -/
 theorem mulPosMono_iff_covariant_pos :
     MulPosMono α ↔ CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
   ⟨@MulPosMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
@@ -821,12 +497,6 @@ theorem mulPosMono_iff_covariant_pos :
       · exact @CovariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align mul_pos_mono_iff_covariant_pos mulPosMono_iff_covariant_pos
 
-/- warning: pos_mul_reflect_lt_iff_contravariant_pos -> posMulReflectLT_iff_contravariant_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4983 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4983) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5014 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5014))
-Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt_iff_contravariant_pos posMulReflectLT_iff_contravariant_posₓ'. -/
 theorem posMulReflectLT_iff_contravariant_pos :
     PosMulReflectLT α ↔ ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
   ⟨@PosMulReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
@@ -836,12 +506,6 @@ theorem posMulReflectLT_iff_contravariant_pos :
       · exact @ContravariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align pos_mul_reflect_lt_iff_contravariant_pos posMulReflectLT_iff_contravariant_pos
 
-/- warning: mul_pos_reflect_lt_iff_contravariant_pos -> mulPosReflectLT_iff_contravariant_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5121 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5121) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5152 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5152))
-Case conversion may be inaccurate. Consider using '#align mul_pos_reflect_lt_iff_contravariant_pos mulPosReflectLT_iff_contravariant_posₓ'. -/
 theorem mulPosReflectLT_iff_contravariant_pos :
     MulPosReflectLT α ↔ ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
   ⟨@MulPosReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
@@ -851,36 +515,18 @@ theorem mulPosReflectLT_iff_contravariant_pos :
       · exact @ContravariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align mul_pos_reflect_lt_iff_contravariant_pos mulPosReflectLT_iff_contravariant_pos
 
-/- warning: pos_mul_strict_mono.to_pos_mul_mono -> PosMulStrictMono.toPosMulMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align pos_mul_strict_mono.to_pos_mul_mono PosMulStrictMono.toPosMulMonoₓ'. -/
 -- see Note [lower instance priority]
 instance (priority := 100) PosMulStrictMono.toPosMulMono [PosMulStrictMono α] : PosMulMono α :=
   posMulMono_iff_covariant_pos.2 <|
     ⟨fun a => StrictMono.monotone <| @CovariantClass.elim _ _ _ _ _ _⟩
 #align pos_mul_strict_mono.to_pos_mul_mono PosMulStrictMono.toPosMulMono
 
-/- warning: mul_pos_strict_mono.to_mul_pos_mono -> MulPosStrictMono.toMulPosMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align mul_pos_strict_mono.to_mul_pos_mono MulPosStrictMono.toMulPosMonoₓ'. -/
 -- see Note [lower instance priority]
 instance (priority := 100) MulPosStrictMono.toMulPosMono [MulPosStrictMono α] : MulPosMono α :=
   mulPosMono_iff_covariant_pos.2 <|
     ⟨fun a => StrictMono.monotone <| @CovariantClass.elim _ _ _ _ _ _⟩
 #align mul_pos_strict_mono.to_mul_pos_mono MulPosStrictMono.toMulPosMono
 
-/- warning: pos_mul_mono_rev.to_pos_mul_reflect_lt -> PosMulMonoRev.toPosMulReflectLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulMonoRev.toPosMulReflectLTₓ'. -/
 -- see Note [lower instance priority]
 instance (priority := 100) PosMulMonoRev.toPosMulReflectLT [PosMulMonoRev α] : PosMulReflectLT α :=
   posMulReflectLT_iff_contravariant_pos.2
@@ -888,12 +534,6 @@ instance (priority := 100) PosMulMonoRev.toPosMulReflectLT [PosMulMonoRev α] :
       (le_of_mul_le_mul_of_pos_left h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
 #align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulMonoRev.toPosMulReflectLT
 
-/- warning: mul_pos_mono_rev.to_mul_pos_reflect_lt -> MulPosMonoRev.toMulPosReflectLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosMonoRev.toMulPosReflectLTₓ'. -/
 -- see Note [lower instance priority]
 instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] : MulPosReflectLT α :=
   mulPosReflectLT_iff_contravariant_pos.2
@@ -901,35 +541,17 @@ instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] :
       (le_of_mul_le_mul_of_pos_right h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
 #align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosMonoRev.toMulPosReflectLT
 
-/- warning: mul_left_cancel_iff_of_pos -> mul_left_cancel_iff_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c)) (Eq.{succ u1} α b c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c)) (Eq.{succ u1} α b c))
-Case conversion may be inaccurate. Consider using '#align mul_left_cancel_iff_of_pos mul_left_cancel_iff_of_posₓ'. -/
 theorem mul_left_cancel_iff_of_pos [PosMulMonoRev α] (a0 : 0 < a) : a * b = a * c ↔ b = c :=
   ⟨fun h => (le_of_mul_le_mul_of_pos_left h.le a0).antisymm <| le_of_mul_le_mul_of_pos_left h.ge a0,
     congr_arg _⟩
 #align mul_left_cancel_iff_of_pos mul_left_cancel_iff_of_pos
 
-/- warning: mul_right_cancel_iff_of_pos -> mul_right_cancel_iff_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) c b)) (Eq.{succ u1} α a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) c b)) (Eq.{succ u1} α a c))
-Case conversion may be inaccurate. Consider using '#align mul_right_cancel_iff_of_pos mul_right_cancel_iff_of_posₓ'. -/
 theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c * b ↔ a = c :=
   ⟨fun h =>
     (le_of_mul_le_mul_of_pos_right h.le b0).antisymm <| le_of_mul_le_mul_of_pos_right h.ge b0,
     congr_arg _⟩
 #align mul_right_cancel_iff_of_pos mul_right_cancel_iff_of_pos
 
-/- warning: mul_eq_mul_iff_eq_and_eq_of_pos -> mul_eq_mul_iff_eq_and_eq_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) d) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) d) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
-Case conversion may be inaccurate. Consider using '#align mul_eq_mul_iff_eq_and_eq_of_pos mul_eq_mul_iff_eq_and_eq_of_posₓ'. -/
 theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
     [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (a0 : 0 < a) (d0 : 0 < d) :
     a * c = b * d ↔ a = b ∧ c = d :=
@@ -942,12 +564,6 @@ theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono
   exact ((mul_lt_mul_of_pos_of_pos hac hbd a0 d0).Ne h).elim
 #align mul_eq_mul_iff_eq_and_eq_of_pos mul_eq_mul_iff_eq_and_eq_of_pos
 
-/- warning: mul_eq_mul_iff_eq_and_eq_of_pos' -> mul_eq_mul_iff_eq_and_eq_of_pos' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
-Case conversion may be inaccurate. Consider using '#align mul_eq_mul_iff_eq_and_eq_of_pos' mul_eq_mul_iff_eq_and_eq_of_pos'ₓ'. -/
 theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
     [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (b0 : 0 < b) (c0 : 0 < c) :
     a * c = b * d ↔ a = b ∧ c = d :=
@@ -966,12 +582,6 @@ section LinearOrder
 
 variable [LinearOrder α]
 
-/- warning: pos_and_pos_or_neg_and_neg_of_mul_pos -> pos_and_pos_or_neg_and_neg_of_mul_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Or (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b)) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (Or (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_posₓ'. -/
 theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b) :
     0 < a ∧ 0 < b ∨ a < 0 ∧ b < 0 :=
   by
@@ -983,72 +593,30 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
     exact mul_nonpos_of_nonpos_of_nonneg ha.le hb
 #align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_pos
 
-/- warning: neg_of_mul_pos_right -> neg_of_mul_pos_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align neg_of_mul_pos_right neg_of_mul_pos_rightₓ'. -/
 theorem neg_of_mul_pos_right [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha : a ≤ 0) : b < 0 :=
   ((pos_and_pos_or_neg_and_neg_of_mul_pos h).resolve_left fun h => h.1.not_le ha).2
 #align neg_of_mul_pos_right neg_of_mul_pos_right
 
-/- warning: neg_of_mul_pos_left -> neg_of_mul_pos_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align neg_of_mul_pos_left neg_of_mul_pos_leftₓ'. -/
 theorem neg_of_mul_pos_left [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha : b ≤ 0) : a < 0 :=
   ((pos_and_pos_or_neg_and_neg_of_mul_pos h).resolve_left fun h => h.2.not_le ha).1
 #align neg_of_mul_pos_left neg_of_mul_pos_left
 
-/- warning: neg_iff_neg_of_mul_pos -> neg_iff_neg_of_mul_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align neg_iff_neg_of_mul_pos neg_iff_neg_of_mul_posₓ'. -/
 theorem neg_iff_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b) : a < 0 ↔ b < 0 :=
   ⟨neg_of_mul_pos_right hab ∘ le_of_lt, neg_of_mul_pos_left hab ∘ le_of_lt⟩
 #align neg_iff_neg_of_mul_pos neg_iff_neg_of_mul_pos
 
-/- warning: left.neg_of_mul_neg_left -> Left.neg_of_mul_neg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align left.neg_of_mul_neg_left Left.neg_of_mul_neg_leftₓ'. -/
 theorem Left.neg_of_mul_neg_left [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ a) : b < 0 :=
   lt_of_not_ge fun h2 : b ≥ 0 => (Left.mul_nonneg h1 h2).not_lt h
 #align left.neg_of_mul_neg_left Left.neg_of_mul_neg_left
 
-/- warning: right.neg_of_mul_neg_left -> Right.neg_of_mul_neg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align right.neg_of_mul_neg_left Right.neg_of_mul_neg_leftₓ'. -/
 theorem Right.neg_of_mul_neg_left [MulPosMono α] (h : a * b < 0) (h1 : 0 ≤ a) : b < 0 :=
   lt_of_not_ge fun h2 : b ≥ 0 => (Right.mul_nonneg h1 h2).not_lt h
 #align right.neg_of_mul_neg_left Right.neg_of_mul_neg_left
 
-/- warning: left.neg_of_mul_neg_right -> Left.neg_of_mul_neg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align left.neg_of_mul_neg_right Left.neg_of_mul_neg_rightₓ'. -/
 theorem Left.neg_of_mul_neg_right [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ b) : a < 0 :=
   lt_of_not_ge fun h2 : a ≥ 0 => (Left.mul_nonneg h2 h1).not_lt h
 #align left.neg_of_mul_neg_right Left.neg_of_mul_neg_right
 
-/- warning: right.neg_of_mul_neg_right -> Right.neg_of_mul_neg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align right.neg_of_mul_neg_right Right.neg_of_mul_neg_rightₓ'. -/
 theorem Right.neg_of_mul_neg_right [MulPosMono α] (h : a * b < 0) (h1 : 0 ≤ b) : a < 0 :=
   lt_of_not_ge fun h2 : a ≥ 0 => (Right.mul_nonneg h2 h1).not_lt h
 #align right.neg_of_mul_neg_right Right.neg_of_mul_neg_right
@@ -1069,46 +637,22 @@ variable [Preorder α]
 which assume left covariance. -/
 
 
-/- warning: le_mul_iff_one_le_right -> le_mul_iff_one_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
-Case conversion may be inaccurate. Consider using '#align le_mul_iff_one_le_right le_mul_iff_one_le_rightₓ'. -/
 @[simp]
 theorem le_mul_iff_one_le_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a ≤ a * b ↔ 1 ≤ b :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align le_mul_iff_one_le_right le_mul_iff_one_le_right
 
-/- warning: lt_mul_iff_one_lt_right -> lt_mul_iff_one_lt_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
-Case conversion may be inaccurate. Consider using '#align lt_mul_iff_one_lt_right lt_mul_iff_one_lt_rightₓ'. -/
 @[simp]
 theorem lt_mul_iff_one_lt_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a < a * b ↔ 1 < b :=
   Iff.trans (by rw [mul_one]) (mul_lt_mul_left a0)
 #align lt_mul_iff_one_lt_right lt_mul_iff_one_lt_right
 
-/- warning: mul_le_iff_le_one_right -> mul_le_iff_le_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mul_le_iff_le_one_right mul_le_iff_le_one_rightₓ'. -/
 @[simp]
 theorem mul_le_iff_le_one_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a ↔ b ≤ 1 :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align mul_le_iff_le_one_right mul_le_iff_le_one_right
 
-/- warning: mul_lt_iff_lt_one_right -> mul_lt_iff_lt_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mul_lt_iff_lt_one_right mul_lt_iff_lt_one_rightₓ'. -/
 @[simp]
 theorem mul_lt_iff_lt_one_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a * b < a ↔ b < 1 :=
@@ -1119,46 +663,22 @@ theorem mul_lt_iff_lt_one_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 :
 which assume right covariance. -/
 
 
-/- warning: le_mul_iff_one_le_left -> le_mul_iff_one_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
-Case conversion may be inaccurate. Consider using '#align le_mul_iff_one_le_left le_mul_iff_one_le_leftₓ'. -/
 @[simp]
 theorem le_mul_iff_one_le_left [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : a ≤ b * a ↔ 1 ≤ b :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right a0)
 #align le_mul_iff_one_le_left le_mul_iff_one_le_left
 
-/- warning: lt_mul_iff_one_lt_left -> lt_mul_iff_one_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
-Case conversion may be inaccurate. Consider using '#align lt_mul_iff_one_lt_left lt_mul_iff_one_lt_leftₓ'. -/
 @[simp]
 theorem lt_mul_iff_one_lt_left [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a) :
     a < b * a ↔ 1 < b :=
   Iff.trans (by rw [one_mul]) (mul_lt_mul_right a0)
 #align lt_mul_iff_one_lt_left lt_mul_iff_one_lt_left
 
-/- warning: mul_le_iff_le_one_left -> mul_le_iff_le_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mul_le_iff_le_one_left mul_le_iff_le_one_leftₓ'. -/
 @[simp]
 theorem mul_le_iff_le_one_left [MulPosMono α] [MulPosMonoRev α] (b0 : 0 < b) : a * b ≤ b ↔ a ≤ 1 :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right b0)
 #align mul_le_iff_le_one_left mul_le_iff_le_one_left
 
-/- warning: mul_lt_iff_lt_one_left -> mul_lt_iff_lt_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
-Case conversion may be inaccurate. Consider using '#align mul_lt_iff_lt_one_left mul_lt_iff_lt_one_leftₓ'. -/
 @[simp]
 theorem mul_lt_iff_lt_one_left [MulPosStrictMono α] [MulPosReflectLT α] (b0 : 0 < b) :
     a * b < b ↔ a < 1 :=
@@ -1171,82 +691,34 @@ Variants with `< 0` and `≤ 0` instead of `0 <` and `0 ≤` appear in `algebra/
 imports this file) as they need additional results which are not yet available here. -/
 
 
-/- warning: mul_le_of_le_one_left -> mul_le_of_le_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_left mul_le_of_le_one_leftₓ'. -/
 theorem mul_le_of_le_one_left [MulPosMono α] (hb : 0 ≤ b) (h : a ≤ 1) : a * b ≤ b := by
   simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
 #align mul_le_of_le_one_left mul_le_of_le_one_left
 
-/- warning: le_mul_of_one_le_left -> le_mul_of_one_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align le_mul_of_one_le_left le_mul_of_one_le_leftₓ'. -/
 theorem le_mul_of_one_le_left [MulPosMono α] (hb : 0 ≤ b) (h : 1 ≤ a) : b ≤ a * b := by
   simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
 #align le_mul_of_one_le_left le_mul_of_one_le_left
 
-/- warning: mul_le_of_le_one_right -> mul_le_of_le_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_right mul_le_of_le_one_rightₓ'. -/
 theorem mul_le_of_le_one_right [PosMulMono α] (ha : 0 ≤ a) (h : b ≤ 1) : a * b ≤ a := by
   simpa only [mul_one] using mul_le_mul_of_nonneg_left h ha
 #align mul_le_of_le_one_right mul_le_of_le_one_right
 
-/- warning: le_mul_of_one_le_right -> le_mul_of_one_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align le_mul_of_one_le_right le_mul_of_one_le_rightₓ'. -/
 theorem le_mul_of_one_le_right [PosMulMono α] (ha : 0 ≤ a) (h : 1 ≤ b) : a ≤ a * b := by
   simpa only [mul_one] using mul_le_mul_of_nonneg_left h ha
 #align le_mul_of_one_le_right le_mul_of_one_le_right
 
-/- warning: mul_lt_of_lt_one_left -> mul_lt_of_lt_one_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_left mul_lt_of_lt_one_leftₓ'. -/
 theorem mul_lt_of_lt_one_left [MulPosStrictMono α] (hb : 0 < b) (h : a < 1) : a * b < b := by
   simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
 #align mul_lt_of_lt_one_left mul_lt_of_lt_one_left
 
-/- warning: lt_mul_of_one_lt_left -> lt_mul_of_one_lt_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_left lt_mul_of_one_lt_leftₓ'. -/
 theorem lt_mul_of_one_lt_left [MulPosStrictMono α] (hb : 0 < b) (h : 1 < a) : b < a * b := by
   simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
 #align lt_mul_of_one_lt_left lt_mul_of_one_lt_left
 
-/- warning: mul_lt_of_lt_one_right -> mul_lt_of_lt_one_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_right mul_lt_of_lt_one_rightₓ'. -/
 theorem mul_lt_of_lt_one_right [PosMulStrictMono α] (ha : 0 < a) (h : b < 1) : a * b < a := by
   simpa only [mul_one] using mul_lt_mul_of_pos_left h ha
 #align mul_lt_of_lt_one_right mul_lt_of_lt_one_right
 
-/- warning: lt_mul_of_one_lt_right -> lt_mul_of_one_lt_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_right lt_mul_of_one_lt_rightₓ'. -/
 theorem lt_mul_of_one_lt_right [PosMulStrictMono α] (ha : 0 < a) (h : 1 < b) : a < a * b := by
   simpa only [mul_one] using mul_lt_mul_of_pos_left h ha
 #align lt_mul_of_one_lt_right lt_mul_of_one_lt_right
@@ -1254,12 +726,6 @@ theorem lt_mul_of_one_lt_right [PosMulStrictMono α] (ha : 0 < a) (h : 1 < b) :
 /-! Lemmas of the form `b ≤ c → a ≤ 1 → b * a ≤ c`. -/
 
 
-/- warning: mul_le_of_le_of_le_one_of_nonneg -> mul_le_of_le_of_le_one_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_le_of_le_one_of_nonneg mul_le_of_le_of_le_one_of_nonnegₓ'. -/
 /- Yaël: What's the point of these lemmas? They just chain an existing lemma with an assumption in
 all possible ways, thereby artificially inflating the API and making the truly relevant lemmas hard
 to find -/
@@ -1268,103 +734,49 @@ theorem mul_le_of_le_of_le_one_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : a 
   (mul_le_of_le_one_right hb ha).trans h
 #align mul_le_of_le_of_le_one_of_nonneg mul_le_of_le_of_le_one_of_nonneg
 
-/- warning: mul_lt_of_le_of_lt_one_of_pos -> mul_lt_of_le_of_lt_one_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_of_lt_one_of_pos mul_lt_of_le_of_lt_one_of_posₓ'. -/
 theorem mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha : a < 1) (b0 : 0 < b) :
     b * a < c :=
   (mul_lt_of_lt_one_right b0 ha).trans_le bc
 #align mul_lt_of_le_of_lt_one_of_pos mul_lt_of_le_of_lt_one_of_pos
 
-/- warning: mul_lt_of_lt_of_le_one_of_nonneg -> mul_lt_of_lt_of_le_one_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_of_le_one_of_nonneg mul_lt_of_lt_of_le_one_of_nonnegₓ'. -/
 theorem mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (h : b < c) (ha : a ≤ 1) (hb : 0 ≤ b) :
     b * a < c :=
   (mul_le_of_le_one_right hb ha).trans_lt h
 #align mul_lt_of_lt_of_le_one_of_nonneg mul_lt_of_lt_of_le_one_of_nonneg
 
-/- warning: left.mul_le_one_of_le_of_le -> Left.mul_le_one_of_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align left.mul_le_one_of_le_of_le Left.mul_le_one_of_le_of_leₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.mul_le_one_of_le_of_le [PosMulMono α] (ha : a ≤ 1) (hb : b ≤ 1) (a0 : 0 ≤ a) :
     a * b ≤ 1 :=
   mul_le_of_le_of_le_one_of_nonneg ha hb a0
 #align left.mul_le_one_of_le_of_le Left.mul_le_one_of_le_of_le
 
-/- warning: left.mul_lt_of_le_of_lt_one_of_pos -> Left.mul_lt_of_le_of_lt_one_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align left.mul_lt_of_le_of_lt_one_of_pos Left.mul_lt_of_le_of_lt_one_of_posₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (ha : a ≤ 1) (hb : b < 1)
     (a0 : 0 < a) : a * b < 1 :=
   mul_lt_of_le_of_lt_one_of_pos ha hb a0
 #align left.mul_lt_of_le_of_lt_one_of_pos Left.mul_lt_of_le_of_lt_one_of_pos
 
-/- warning: left.mul_lt_of_lt_of_le_one_of_nonneg -> Left.mul_lt_of_lt_of_le_one_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align left.mul_lt_of_lt_of_le_one_of_nonneg Left.mul_lt_of_lt_of_le_one_of_nonnegₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (ha : a < 1) (hb : b ≤ 1)
     (a0 : 0 ≤ a) : a * b < 1 :=
   mul_lt_of_lt_of_le_one_of_nonneg ha hb a0
 #align left.mul_lt_of_lt_of_le_one_of_nonneg Left.mul_lt_of_lt_of_le_one_of_nonneg
 
-/- warning: mul_le_of_le_of_le_one' -> mul_le_of_le_of_le_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_le_of_le_one' mul_le_of_le_of_le_one'ₓ'. -/
 theorem mul_le_of_le_of_le_one' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (ha : a ≤ 1) (a0 : 0 ≤ a)
     (c0 : 0 ≤ c) : b * a ≤ c :=
   (mul_le_mul_of_nonneg_right bc a0).trans <| mul_le_of_le_one_right c0 ha
 #align mul_le_of_le_of_le_one' mul_le_of_le_of_le_one'
 
-/- warning: mul_lt_of_lt_of_le_one' -> mul_lt_of_lt_of_le_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_of_le_one' mul_lt_of_lt_of_le_one'ₓ'. -/
 theorem mul_lt_of_lt_of_le_one' [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : a ≤ 1)
     (a0 : 0 < a) (c0 : 0 ≤ c) : b * a < c :=
   (mul_lt_mul_of_pos_right bc a0).trans_le <| mul_le_of_le_one_right c0 ha
 #align mul_lt_of_lt_of_le_one' mul_lt_of_lt_of_le_one'
 
-/- warning: mul_lt_of_le_of_lt_one' -> mul_lt_of_le_of_lt_one' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_of_lt_one' mul_lt_of_le_of_lt_one'ₓ'. -/
 theorem mul_lt_of_le_of_lt_one' [PosMulStrictMono α] [MulPosMono α] (bc : b ≤ c) (ha : a < 1)
     (a0 : 0 ≤ a) (c0 : 0 < c) : b * a < c :=
   (mul_le_mul_of_nonneg_right bc a0).trans_lt <| mul_lt_of_lt_one_right c0 ha
 #align mul_lt_of_le_of_lt_one' mul_lt_of_le_of_lt_one'
 
-/- warning: mul_lt_of_lt_of_lt_one_of_pos -> mul_lt_of_lt_of_lt_one_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_of_lt_one_of_pos mul_lt_of_lt_of_lt_one_of_posₓ'. -/
 theorem mul_lt_of_lt_of_lt_one_of_pos [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : a ≤ 1)
     (a0 : 0 < a) (c0 : 0 ≤ c) : b * a < c :=
   (mul_lt_mul_of_pos_right bc a0).trans_le <| mul_le_of_le_one_right c0 ha
@@ -1373,114 +785,54 @@ theorem mul_lt_of_lt_of_lt_one_of_pos [PosMulMono α] [MulPosStrictMono α] (bc
 /-! Lemmas of the form `b ≤ c → 1 ≤ a → b ≤ c * a`. -/
 
 
-/- warning: le_mul_of_le_of_one_le_of_nonneg -> le_mul_of_le_of_one_le_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align le_mul_of_le_of_one_le_of_nonneg le_mul_of_le_of_one_le_of_nonnegₓ'. -/
 theorem le_mul_of_le_of_one_le_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : 1 ≤ a) (hc : 0 ≤ c) :
     b ≤ c * a :=
   h.trans <| le_mul_of_one_le_right hc ha
 #align le_mul_of_le_of_one_le_of_nonneg le_mul_of_le_of_one_le_of_nonneg
 
-/- warning: lt_mul_of_le_of_one_lt_of_pos -> lt_mul_of_le_of_one_lt_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_le_of_one_lt_of_pos lt_mul_of_le_of_one_lt_of_posₓ'. -/
 theorem lt_mul_of_le_of_one_lt_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha : 1 < a) (c0 : 0 < c) :
     b < c * a :=
   bc.trans_lt <| lt_mul_of_one_lt_right c0 ha
 #align lt_mul_of_le_of_one_lt_of_pos lt_mul_of_le_of_one_lt_of_pos
 
-/- warning: lt_mul_of_lt_of_one_le_of_nonneg -> lt_mul_of_lt_of_one_le_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_of_one_le_of_nonneg lt_mul_of_lt_of_one_le_of_nonnegₓ'. -/
 theorem lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (h : b < c) (ha : 1 ≤ a) (hc : 0 ≤ c) :
     b < c * a :=
   h.trans_le <| le_mul_of_one_le_right hc ha
 #align lt_mul_of_lt_of_one_le_of_nonneg lt_mul_of_lt_of_one_le_of_nonneg
 
-/- warning: left.one_le_mul_of_le_of_le -> Left.one_le_mul_of_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align left.one_le_mul_of_le_of_le Left.one_le_mul_of_le_of_leₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.one_le_mul_of_le_of_le [PosMulMono α] (ha : 1 ≤ a) (hb : 1 ≤ b) (a0 : 0 ≤ a) :
     1 ≤ a * b :=
   le_mul_of_le_of_one_le_of_nonneg ha hb a0
 #align left.one_le_mul_of_le_of_le Left.one_le_mul_of_le_of_le
 
-/- warning: left.one_lt_mul_of_le_of_lt_of_pos -> Left.one_lt_mul_of_le_of_lt_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align left.one_lt_mul_of_le_of_lt_of_pos Left.one_lt_mul_of_le_of_lt_of_posₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.one_lt_mul_of_le_of_lt_of_pos [PosMulStrictMono α] (ha : 1 ≤ a) (hb : 1 < b)
     (a0 : 0 < a) : 1 < a * b :=
   lt_mul_of_le_of_one_lt_of_pos ha hb a0
 #align left.one_lt_mul_of_le_of_lt_of_pos Left.one_lt_mul_of_le_of_lt_of_pos
 
-/- warning: left.lt_mul_of_lt_of_one_le_of_nonneg -> Left.lt_mul_of_lt_of_one_le_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align left.lt_mul_of_lt_of_one_le_of_nonneg Left.lt_mul_of_lt_of_one_le_of_nonnegₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (ha : 1 < a) (hb : 1 ≤ b)
     (a0 : 0 ≤ a) : 1 < a * b :=
   lt_mul_of_lt_of_one_le_of_nonneg ha hb a0
 #align left.lt_mul_of_lt_of_one_le_of_nonneg Left.lt_mul_of_lt_of_one_le_of_nonneg
 
-/- warning: le_mul_of_le_of_one_le' -> le_mul_of_le_of_one_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align le_mul_of_le_of_one_le' le_mul_of_le_of_one_le'ₓ'. -/
 theorem le_mul_of_le_of_one_le' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (ha : 1 ≤ a) (a0 : 0 ≤ a)
     (b0 : 0 ≤ b) : b ≤ c * a :=
   (le_mul_of_one_le_right b0 ha).trans <| mul_le_mul_of_nonneg_right bc a0
 #align le_mul_of_le_of_one_le' le_mul_of_le_of_one_le'
 
-/- warning: lt_mul_of_le_of_one_lt' -> lt_mul_of_le_of_one_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_le_of_one_lt' lt_mul_of_le_of_one_lt'ₓ'. -/
 theorem lt_mul_of_le_of_one_lt' [PosMulStrictMono α] [MulPosMono α] (bc : b ≤ c) (ha : 1 < a)
     (a0 : 0 ≤ a) (b0 : 0 < b) : b < c * a :=
   (lt_mul_of_one_lt_right b0 ha).trans_le <| mul_le_mul_of_nonneg_right bc a0
 #align lt_mul_of_le_of_one_lt' lt_mul_of_le_of_one_lt'
 
-/- warning: lt_mul_of_lt_of_one_le' -> lt_mul_of_lt_of_one_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_of_one_le' lt_mul_of_lt_of_one_le'ₓ'. -/
 theorem lt_mul_of_lt_of_one_le' [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : 1 ≤ a)
     (a0 : 0 < a) (b0 : 0 ≤ b) : b < c * a :=
   (le_mul_of_one_le_right b0 ha).trans_lt <| mul_lt_mul_of_pos_right bc a0
 #align lt_mul_of_lt_of_one_le' lt_mul_of_lt_of_one_le'
 
-/- warning: lt_mul_of_lt_of_one_lt_of_pos -> lt_mul_of_lt_of_one_lt_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_of_one_lt_of_pos lt_mul_of_lt_of_one_lt_of_posₓ'. -/
 theorem lt_mul_of_lt_of_one_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (bc : b < c)
     (ha : 1 < a) (a0 : 0 < a) (b0 : 0 < b) : b < c * a :=
   (lt_mul_of_one_lt_right b0 ha).trans <| mul_lt_mul_of_pos_right bc a0
@@ -1489,114 +841,54 @@ theorem lt_mul_of_lt_of_one_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α
 /-! Lemmas of the form `a ≤ 1 → b ≤ c → a * b ≤ c`. -/
 
 
-/- warning: mul_le_of_le_one_of_le_of_nonneg -> mul_le_of_le_one_of_le_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_of_le_of_nonneg mul_le_of_le_one_of_le_of_nonnegₓ'. -/
 theorem mul_le_of_le_one_of_le_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b ≤ c) (hb : 0 ≤ b) :
     a * b ≤ c :=
   (mul_le_of_le_one_left hb ha).trans h
 #align mul_le_of_le_one_of_le_of_nonneg mul_le_of_le_one_of_le_of_nonneg
 
-/- warning: mul_lt_of_lt_one_of_le_of_pos -> mul_lt_of_lt_one_of_le_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_of_le_of_pos mul_lt_of_lt_one_of_le_of_posₓ'. -/
 theorem mul_lt_of_lt_one_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (h : b ≤ c) (hb : 0 < b) :
     a * b < c :=
   (mul_lt_of_lt_one_left hb ha).trans_le h
 #align mul_lt_of_lt_one_of_le_of_pos mul_lt_of_lt_one_of_le_of_pos
 
-/- warning: mul_lt_of_le_one_of_lt_of_nonneg -> mul_lt_of_le_one_of_lt_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_one_of_lt_of_nonneg mul_lt_of_le_one_of_lt_of_nonnegₓ'. -/
 theorem mul_lt_of_le_one_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b < c) (hb : 0 ≤ b) :
     a * b < c :=
   (mul_le_of_le_one_left hb ha).trans_lt h
 #align mul_lt_of_le_one_of_lt_of_nonneg mul_lt_of_le_one_of_lt_of_nonneg
 
-/- warning: right.mul_lt_one_of_lt_of_le_of_pos -> Right.mul_lt_one_of_lt_of_le_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align right.mul_lt_one_of_lt_of_le_of_pos Right.mul_lt_one_of_lt_of_le_of_posₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.mul_lt_one_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (hb : b ≤ 1)
     (b0 : 0 < b) : a * b < 1 :=
   mul_lt_of_lt_one_of_le_of_pos ha hb b0
 #align right.mul_lt_one_of_lt_of_le_of_pos Right.mul_lt_one_of_lt_of_le_of_pos
 
-/- warning: right.mul_lt_one_of_le_of_lt_of_nonneg -> Right.mul_lt_one_of_le_of_lt_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align right.mul_lt_one_of_le_of_lt_of_nonneg Right.mul_lt_one_of_le_of_lt_of_nonnegₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.mul_lt_one_of_le_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (hb : b < 1)
     (b0 : 0 ≤ b) : a * b < 1 :=
   mul_lt_of_le_one_of_lt_of_nonneg ha hb b0
 #align right.mul_lt_one_of_le_of_lt_of_nonneg Right.mul_lt_one_of_le_of_lt_of_nonneg
 
-/- warning: mul_lt_of_lt_one_of_lt_of_pos -> mul_lt_of_lt_one_of_lt_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_of_lt_of_pos mul_lt_of_lt_one_of_lt_of_posₓ'. -/
 theorem mul_lt_of_lt_one_of_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (ha : a < 1)
     (bc : b < c) (a0 : 0 < a) (c0 : 0 < c) : a * b < c :=
   (mul_lt_mul_of_pos_left bc a0).trans <| mul_lt_of_lt_one_left c0 ha
 #align mul_lt_of_lt_one_of_lt_of_pos mul_lt_of_lt_one_of_lt_of_pos
 
-/- warning: right.mul_le_one_of_le_of_le -> Right.mul_le_one_of_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align right.mul_le_one_of_le_of_le Right.mul_le_one_of_le_of_leₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.mul_le_one_of_le_of_le [MulPosMono α] (ha : a ≤ 1) (hb : b ≤ 1) (b0 : 0 ≤ b) :
     a * b ≤ 1 :=
   mul_le_of_le_one_of_le_of_nonneg ha hb b0
 #align right.mul_le_one_of_le_of_le Right.mul_le_one_of_le_of_le
 
-/- warning: mul_le_of_le_one_of_le' -> mul_le_of_le_one_of_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_of_le' mul_le_of_le_one_of_le'ₓ'. -/
 theorem mul_le_of_le_one_of_le' [PosMulMono α] [MulPosMono α] (ha : a ≤ 1) (bc : b ≤ c) (a0 : 0 ≤ a)
     (c0 : 0 ≤ c) : a * b ≤ c :=
   (mul_le_mul_of_nonneg_left bc a0).trans <| mul_le_of_le_one_left c0 ha
 #align mul_le_of_le_one_of_le' mul_le_of_le_one_of_le'
 
-/- warning: mul_lt_of_lt_one_of_le' -> mul_lt_of_lt_one_of_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_of_le' mul_lt_of_lt_one_of_le'ₓ'. -/
 theorem mul_lt_of_lt_one_of_le' [PosMulMono α] [MulPosStrictMono α] (ha : a < 1) (bc : b ≤ c)
     (a0 : 0 ≤ a) (c0 : 0 < c) : a * b < c :=
   (mul_le_mul_of_nonneg_left bc a0).trans_lt <| mul_lt_of_lt_one_left c0 ha
 #align mul_lt_of_lt_one_of_le' mul_lt_of_lt_one_of_le'
 
-/- warning: mul_lt_of_le_one_of_lt' -> mul_lt_of_le_one_of_lt' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
-Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_one_of_lt' mul_lt_of_le_one_of_lt'ₓ'. -/
 theorem mul_lt_of_le_one_of_lt' [PosMulStrictMono α] [MulPosMono α] (ha : a ≤ 1) (bc : b < c)
     (a0 : 0 < a) (c0 : 0 ≤ c) : a * b < c :=
   (mul_lt_mul_of_pos_left bc a0).trans_le <| mul_le_of_le_one_left c0 ha
@@ -1605,181 +897,85 @@ theorem mul_lt_of_le_one_of_lt' [PosMulStrictMono α] [MulPosMono α] (ha : a 
 /-! Lemmas of the form `1 ≤ a → b ≤ c → b ≤ a * c`. -/
 
 
-/- warning: lt_mul_of_one_lt_of_le_of_pos -> lt_mul_of_one_lt_of_le_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_of_le_of_pos lt_mul_of_one_lt_of_le_of_posₓ'. -/
 theorem lt_mul_of_one_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b ≤ c) (hc : 0 < c) :
     b < a * c :=
   h.trans_lt <| lt_mul_of_one_lt_left hc ha
 #align lt_mul_of_one_lt_of_le_of_pos lt_mul_of_one_lt_of_le_of_pos
 
-/- warning: lt_mul_of_one_le_of_lt_of_nonneg -> lt_mul_of_one_le_of_lt_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_le_of_lt_of_nonneg lt_mul_of_one_le_of_lt_of_nonnegₓ'. -/
 theorem lt_mul_of_one_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b < c) (hc : 0 ≤ c) :
     b < a * c :=
   h.trans_le <| le_mul_of_one_le_left hc ha
 #align lt_mul_of_one_le_of_lt_of_nonneg lt_mul_of_one_le_of_lt_of_nonneg
 
-/- warning: lt_mul_of_one_lt_of_lt_of_pos -> lt_mul_of_one_lt_of_lt_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_of_lt_of_pos lt_mul_of_one_lt_of_lt_of_posₓ'. -/
 theorem lt_mul_of_one_lt_of_lt_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b < c) (hc : 0 < c) :
     b < a * c :=
   h.trans <| lt_mul_of_one_lt_left hc ha
 #align lt_mul_of_one_lt_of_lt_of_pos lt_mul_of_one_lt_of_lt_of_pos
 
-/- warning: right.one_lt_mul_of_lt_of_le_of_pos -> Right.one_lt_mul_of_lt_of_le_of_pos is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align right.one_lt_mul_of_lt_of_le_of_pos Right.one_lt_mul_of_lt_of_le_of_posₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (hb : 1 ≤ b)
     (b0 : 0 < b) : 1 < a * b :=
   lt_mul_of_one_lt_of_le_of_pos ha hb b0
 #align right.one_lt_mul_of_lt_of_le_of_pos Right.one_lt_mul_of_lt_of_le_of_pos
 
-/- warning: right.one_lt_mul_of_le_of_lt_of_nonneg -> Right.one_lt_mul_of_le_of_lt_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align right.one_lt_mul_of_le_of_lt_of_nonneg Right.one_lt_mul_of_le_of_lt_of_nonnegₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (hb : 1 < b)
     (b0 : 0 ≤ b) : 1 < a * b :=
   lt_mul_of_one_le_of_lt_of_nonneg ha hb b0
 #align right.one_lt_mul_of_le_of_lt_of_nonneg Right.one_lt_mul_of_le_of_lt_of_nonneg
 
-/- warning: right.one_lt_mul_of_lt_of_lt -> Right.one_lt_mul_of_lt_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align right.one_lt_mul_of_lt_of_lt Right.one_lt_mul_of_lt_of_ltₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_lt_of_lt [MulPosStrictMono α] (ha : 1 < a) (hb : 1 < b) (b0 : 0 < b) :
     1 < a * b :=
   lt_mul_of_one_lt_of_lt_of_pos ha hb b0
 #align right.one_lt_mul_of_lt_of_lt Right.one_lt_mul_of_lt_of_lt
 
-/- warning: lt_mul_of_one_lt_of_lt_of_nonneg -> lt_mul_of_one_lt_of_lt_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
-Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_of_lt_of_nonneg lt_mul_of_one_lt_of_lt_of_nonnegₓ'. -/
 theorem lt_mul_of_one_lt_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b < c) (hc : 0 ≤ c) :
     b < a * c :=
   h.trans_le <| le_mul_of_one_le_left hc ha
 #align lt_mul_of_one_lt_of_lt_of_nonneg lt_mul_of_one_lt_of_lt_of_nonneg
 
-/- warning: lt_of_mul_lt_of_one_le_of_nonneg_left -> lt_of_mul_lt_of_one_le_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a c)
-Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_of_one_le_of_nonneg_left lt_of_mul_lt_of_one_le_of_nonneg_leftₓ'. -/
 theorem lt_of_mul_lt_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b < c) (hle : 1 ≤ b)
     (ha : 0 ≤ a) : a < c :=
   (le_mul_of_one_le_right ha hle).trans_lt h
 #align lt_of_mul_lt_of_one_le_of_nonneg_left lt_of_mul_lt_of_one_le_of_nonneg_left
 
-/- warning: lt_of_lt_mul_of_le_one_of_nonneg_left -> lt_of_lt_mul_of_le_one_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b)
-Case conversion may be inaccurate. Consider using '#align lt_of_lt_mul_of_le_one_of_nonneg_left lt_of_lt_mul_of_le_one_of_nonneg_leftₓ'. -/
 theorem lt_of_lt_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a < b * c) (hc : c ≤ 1)
     (hb : 0 ≤ b) : a < b :=
   h.trans_le <| mul_le_of_le_one_right hb hc
 #align lt_of_lt_mul_of_le_one_of_nonneg_left lt_of_lt_mul_of_le_one_of_nonneg_left
 
-/- warning: lt_of_lt_mul_of_le_one_of_nonneg_right -> lt_of_lt_mul_of_le_one_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a c)
-Case conversion may be inaccurate. Consider using '#align lt_of_lt_mul_of_le_one_of_nonneg_right lt_of_lt_mul_of_le_one_of_nonneg_rightₓ'. -/
 theorem lt_of_lt_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a < b * c) (hb : b ≤ 1)
     (hc : 0 ≤ c) : a < c :=
   h.trans_le <| mul_le_of_le_one_left hc hb
 #align lt_of_lt_mul_of_le_one_of_nonneg_right lt_of_lt_mul_of_le_one_of_nonneg_right
 
-/- warning: le_mul_of_one_le_of_le_of_nonneg -> le_mul_of_one_le_of_le_of_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
-Case conversion may be inaccurate. Consider using '#align le_mul_of_one_le_of_le_of_nonneg le_mul_of_one_le_of_le_of_nonnegₓ'. -/
 theorem le_mul_of_one_le_of_le_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (bc : b ≤ c) (c0 : 0 ≤ c) :
     b ≤ a * c :=
   bc.trans <| le_mul_of_one_le_left c0 ha
 #align le_mul_of_one_le_of_le_of_nonneg le_mul_of_one_le_of_le_of_nonneg
 
-/- warning: right.one_le_mul_of_le_of_le -> Right.one_le_mul_of_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align right.one_le_mul_of_le_of_le Right.one_le_mul_of_le_of_leₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.one_le_mul_of_le_of_le [MulPosMono α] (ha : 1 ≤ a) (hb : 1 ≤ b) (b0 : 0 ≤ b) :
     1 ≤ a * b :=
   le_mul_of_one_le_of_le_of_nonneg ha hb b0
 #align right.one_le_mul_of_le_of_le Right.one_le_mul_of_le_of_le
 
-/- warning: le_of_mul_le_of_one_le_of_nonneg_left -> le_of_mul_le_of_one_le_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a c)
-Case conversion may be inaccurate. Consider using '#align le_of_mul_le_of_one_le_of_nonneg_left le_of_mul_le_of_one_le_of_nonneg_leftₓ'. -/
 theorem le_of_mul_le_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hb : 1 ≤ b)
     (ha : 0 ≤ a) : a ≤ c :=
   (le_mul_of_one_le_right ha hb).trans h
 #align le_of_mul_le_of_one_le_of_nonneg_left le_of_mul_le_of_one_le_of_nonneg_left
 
-/- warning: le_of_le_mul_of_le_one_of_nonneg_left -> le_of_le_mul_of_le_one_of_nonneg_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a b)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a b)
-Case conversion may be inaccurate. Consider using '#align le_of_le_mul_of_le_one_of_nonneg_left le_of_le_mul_of_le_one_of_nonneg_leftₓ'. -/
 theorem le_of_le_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a ≤ b * c) (hc : c ≤ 1)
     (hb : 0 ≤ b) : a ≤ b :=
   h.trans <| mul_le_of_le_one_right hb hc
 #align le_of_le_mul_of_le_one_of_nonneg_left le_of_le_mul_of_le_one_of_nonneg_left
 
-/- warning: le_of_mul_le_of_one_le_nonneg_right -> le_of_mul_le_of_one_le_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
-Case conversion may be inaccurate. Consider using '#align le_of_mul_le_of_one_le_nonneg_right le_of_mul_le_of_one_le_nonneg_rightₓ'. -/
 theorem le_of_mul_le_of_one_le_nonneg_right [MulPosMono α] (h : a * b ≤ c) (ha : 1 ≤ a)
     (hb : 0 ≤ b) : b ≤ c :=
   (le_mul_of_one_le_left hb ha).trans h
 #align le_of_mul_le_of_one_le_nonneg_right le_of_mul_le_of_one_le_nonneg_right
 
-/- warning: le_of_le_mul_of_le_one_of_nonneg_right -> le_of_le_mul_of_le_one_of_nonneg_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a c)
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a c)
-Case conversion may be inaccurate. Consider using '#align le_of_le_mul_of_le_one_of_nonneg_right le_of_le_mul_of_le_one_of_nonneg_rightₓ'. -/
 theorem le_of_le_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a ≤ b * c) (hb : b ≤ 1)
     (hc : 0 ≤ c) : a ≤ c :=
   h.trans <| mul_le_of_le_one_left hc hb
@@ -1791,12 +987,6 @@ section LinearOrder
 
 variable [LinearOrder α]
 
-/- warning: exists_square_le' -> exists_square_le' is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : LinearOrder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Exists.{succ u1} α (fun (b : α) => LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b b) a))
-but is expected to have type
-  forall {α : Type.{u1}} {a : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : LinearOrder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Exists.{succ u1} α (fun (b : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b b) a))
-Case conversion may be inaccurate. Consider using '#align exists_square_le' exists_square_le'ₓ'. -/
 -- Yaël: What's the point of this lemma? If we have `0 * 0 = 0`, then we can just take `b = 0`.
 -- proven with `a0 : 0 ≤ a` as `exists_square_le`
 theorem exists_square_le' [PosMulStrictMono α] (a0 : 0 < a) : ∃ b : α, b * b ≤ a :=
@@ -1818,88 +1008,40 @@ section PartialOrder
 
 variable [PartialOrder α]
 
-/- warning: pos_mul_mono.to_pos_mul_strict_mono -> PosMulMono.toPosMulStrictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono.to_pos_mul_strict_mono PosMulMono.toPosMulStrictMonoₓ'. -/
 theorem PosMulMono.toPosMulStrictMono [PosMulMono α] : PosMulStrictMono α :=
   ⟨fun x a b h =>
     (mul_le_mul_of_nonneg_left h.le x.2.le).lt_of_ne (h.Ne ∘ mul_left_cancel₀ x.2.ne')⟩
 #align pos_mul_mono.to_pos_mul_strict_mono PosMulMono.toPosMulStrictMono
 
-/- warning: pos_mul_mono_iff_pos_mul_strict_mono -> posMulMono_iff_posMulStrictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)) (PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)) (PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2))
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono_iff_pos_mul_strict_mono posMulMono_iff_posMulStrictMonoₓ'. -/
 theorem posMulMono_iff_posMulStrictMono : PosMulMono α ↔ PosMulStrictMono α :=
   ⟨@PosMulMono.toPosMulStrictMono α _ _, @PosMulStrictMono.toPosMulMono α _ _⟩
 #align pos_mul_mono_iff_pos_mul_strict_mono posMulMono_iff_posMulStrictMono
 
-/- warning: mul_pos_mono.to_mul_pos_strict_mono -> MulPosMono.toMulPosStrictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align mul_pos_mono.to_mul_pos_strict_mono MulPosMono.toMulPosStrictMonoₓ'. -/
 theorem MulPosMono.toMulPosStrictMono [MulPosMono α] : MulPosStrictMono α :=
   ⟨fun x a b h =>
     (mul_le_mul_of_nonneg_right h.le x.2.le).lt_of_ne (h.Ne ∘ mul_right_cancel₀ x.2.ne')⟩
 #align mul_pos_mono.to_mul_pos_strict_mono MulPosMono.toMulPosStrictMono
 
-/- warning: mul_pos_mono_iff_mul_pos_strict_mono -> mulPosMono_iff_mulPosStrictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)) (MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)) (MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2))
-Case conversion may be inaccurate. Consider using '#align mul_pos_mono_iff_mul_pos_strict_mono mulPosMono_iff_mulPosStrictMonoₓ'. -/
 theorem mulPosMono_iff_mulPosStrictMono : MulPosMono α ↔ MulPosStrictMono α :=
   ⟨@MulPosMono.toMulPosStrictMono α _ _, @MulPosStrictMono.toMulPosMono α _ _⟩
 #align mul_pos_mono_iff_mul_pos_strict_mono mulPosMono_iff_mulPosStrictMono
 
-/- warning: pos_mul_reflect_lt.to_pos_mul_mono_rev -> PosMulReflectLT.toPosMulMonoRev is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)], PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt.to_pos_mul_mono_rev PosMulReflectLT.toPosMulMonoRevₓ'. -/
 theorem PosMulReflectLT.toPosMulMonoRev [PosMulReflectLT α] : PosMulMonoRev α :=
   ⟨fun x a b h =>
     h.eq_or_lt.elim (le_of_eq ∘ mul_left_cancel₀ x.2.Ne.symm) fun h' =>
       (lt_of_mul_lt_mul_left h' x.2.le).le⟩
 #align pos_mul_reflect_lt.to_pos_mul_mono_rev PosMulReflectLT.toPosMulMonoRev
 
-/- warning: pos_mul_mono_rev_iff_pos_mul_reflect_lt -> posMulMonoRev_iff_posMulReflectLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)) (PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)) (PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2))
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono_rev_iff_pos_mul_reflect_lt posMulMonoRev_iff_posMulReflectLTₓ'. -/
 theorem posMulMonoRev_iff_posMulReflectLT : PosMulMonoRev α ↔ PosMulReflectLT α :=
   ⟨@PosMulMonoRev.toPosMulReflectLT α _ _, @PosMulReflectLT.toPosMulMonoRev α _ _⟩
 #align pos_mul_mono_rev_iff_pos_mul_reflect_lt posMulMonoRev_iff_posMulReflectLT
 
-/- warning: mul_pos_reflect_lt.to_mul_pos_mono_rev -> MulPosReflectLT.toMulPosMonoRev is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)], MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)
-Case conversion may be inaccurate. Consider using '#align mul_pos_reflect_lt.to_mul_pos_mono_rev MulPosReflectLT.toMulPosMonoRevₓ'. -/
 theorem MulPosReflectLT.toMulPosMonoRev [MulPosReflectLT α] : MulPosMonoRev α :=
   ⟨fun x a b h =>
     h.eq_or_lt.elim (le_of_eq ∘ mul_right_cancel₀ x.2.Ne.symm) fun h' =>
       (lt_of_mul_lt_mul_right h' x.2.le).le⟩
 #align mul_pos_reflect_lt.to_mul_pos_mono_rev MulPosReflectLT.toMulPosMonoRev
 
-/- warning: mul_pos_mono_rev_iff_mul_pos_reflect_lt -> mulPosMonoRev_iff_mulPosReflectLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2)) (MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MulZeroClass.toHasZero.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (PartialOrder.toPreorder.{u1} α _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CancelMonoidWithZero.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2)) (MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α (MulZeroOneClass.toMulZeroClass.{u1} α (MonoidWithZero.toMulZeroOneClass.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)))) (MonoidWithZero.toZero.{u1} α (CancelMonoidWithZero.toMonoidWithZero.{u1} α _inst_1)) (PartialOrder.toPreorder.{u1} α _inst_2))
-Case conversion may be inaccurate. Consider using '#align mul_pos_mono_rev_iff_mul_pos_reflect_lt mulPosMonoRev_iff_mulPosReflectLTₓ'. -/
 theorem mulPosMonoRev_iff_mulPosReflectLT : MulPosMonoRev α ↔ MulPosReflectLT α :=
   ⟨@MulPosMonoRev.toMulPosReflectLT α _ _, @MulPosReflectLT.toMulPosMonoRev α _ _⟩
 #align mul_pos_mono_rev_iff_mul_pos_reflect_lt mulPosMonoRev_iff_mulPosReflectLT
@@ -1912,41 +1054,17 @@ section CommSemigroupHasZero
 
 variable [CommSemigroup α] [Zero α] [Preorder α]
 
-/- warning: pos_mul_strict_mono_iff_mul_pos_strict_mono -> posMulStrictMono_iff_mulPosStrictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulStrictMono.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosStrictMono.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulStrictMono.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosStrictMono.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align pos_mul_strict_mono_iff_mul_pos_strict_mono posMulStrictMono_iff_mulPosStrictMonoₓ'. -/
 theorem posMulStrictMono_iff_mulPosStrictMono : PosMulStrictMono α ↔ MulPosStrictMono α := by
   simp! only [mul_comm]
 #align pos_mul_strict_mono_iff_mul_pos_strict_mono posMulStrictMono_iff_mulPosStrictMono
 
-/- warning: pos_mul_reflect_lt_iff_mul_pos_reflect_lt -> posMulReflectLT_iff_mulPosReflectLT is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulReflectLT.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosReflectLT.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulReflectLT.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosReflectLT.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt_iff_mul_pos_reflect_lt posMulReflectLT_iff_mulPosReflectLTₓ'. -/
 theorem posMulReflectLT_iff_mulPosReflectLT : PosMulReflectLT α ↔ MulPosReflectLT α := by
   simp! only [mul_comm]
 #align pos_mul_reflect_lt_iff_mul_pos_reflect_lt posMulReflectLT_iff_mulPosReflectLT
 
-/- warning: pos_mul_mono_iff_mul_pos_mono -> posMulMono_iff_mulPosMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulMono.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosMono.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulMono.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosMono.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono_iff_mul_pos_mono posMulMono_iff_mulPosMonoₓ'. -/
 theorem posMulMono_iff_mulPosMono : PosMulMono α ↔ MulPosMono α := by simp! only [mul_comm]
 #align pos_mul_mono_iff_mul_pos_mono posMulMono_iff_mulPosMono
 
-/- warning: pos_mul_mono_rev_iff_mul_pos_mono_rev -> posMulMonoRev_iff_mulPosMonoRev is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulMonoRev.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosMonoRev.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CommSemigroup.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α], Iff (PosMulMonoRev.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3) (MulPosMonoRev.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_1)) _inst_2 _inst_3)
-Case conversion may be inaccurate. Consider using '#align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulMonoRev_iff_mulPosMonoRevₓ'. -/
 theorem posMulMonoRev_iff_mulPosMonoRev : PosMulMonoRev α ↔ MulPosMonoRev α := by
   simp! only [mul_comm]
 #align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulMonoRev_iff_mulPosMonoRev

44e29dbc

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -591,9 +591,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align zero_lt_mul_left zero_lt_mul_leftₓ'. -/
 @[simp]
 theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) : 0 < c * b ↔ 0 < b :=
-  by
-  convert mul_lt_mul_left h
-  simp
+  by convert mul_lt_mul_left h; simp
 #align zero_lt_mul_left zero_lt_mul_left
 
 /- warning: right.mul_pos -> Right.mul_pos is a dubious translation:
@@ -625,9 +623,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align zero_lt_mul_right zero_lt_mul_rightₓ'. -/
 @[simp]
 theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
-    0 < b * c ↔ 0 < b := by
-  convert mul_lt_mul_right h
-  simp
+    0 < b * c ↔ 0 < b := by convert mul_lt_mul_right h; simp
 #align zero_lt_mul_right zero_lt_mul_right
 
 /- warning: left.mul_nonneg -> Left.mul_nonneg is a dubious translation:
@@ -889,10 +885,7 @@ Case conversion may be inaccurate. Consider using '#align pos_mul_mono_rev.to_po
 instance (priority := 100) PosMulMonoRev.toPosMulReflectLT [PosMulMonoRev α] : PosMulReflectLT α :=
   posMulReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
-      (le_of_mul_le_mul_of_pos_left h.le a.2).lt_of_ne <|
-        by
-        rintro rfl
-        simpa using h⟩
+      (le_of_mul_le_mul_of_pos_left h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
 #align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulMonoRev.toPosMulReflectLT
 
 /- warning: mul_pos_mono_rev.to_mul_pos_reflect_lt -> MulPosMonoRev.toMulPosReflectLT is a dubious translation:
@@ -905,10 +898,7 @@ Case conversion may be inaccurate. Consider using '#align mul_pos_mono_rev.to_mu
 instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] : MulPosReflectLT α :=
   mulPosReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
-      (le_of_mul_le_mul_of_pos_right h.le a.2).lt_of_ne <|
-        by
-        rintro rfl
-        simpa using h⟩
+      (le_of_mul_le_mul_of_pos_right h.le a.2).lt_of_ne <| by rintro rfl; simpa using h⟩
 #align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosMonoRev.toMulPosReflectLT
 
 /- warning: mul_left_cancel_iff_of_pos -> mul_left_cancel_iff_of_pos is a dubious translation:
@@ -988,8 +978,7 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
   rcases lt_trichotomy 0 a with (ha | rfl | ha)
   · refine' Or.inl ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonneg_of_nonpos ha.le hb
-  · rw [MulZeroClass.zero_mul] at hab
-    exact hab.false.elim
+  · rw [MulZeroClass.zero_mul] at hab; exact hab.false.elim
   · refine' Or.inr ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonpos_of_nonneg ha.le hb
 #align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_pos

44e29dbc

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -151,7 +151,7 @@ variable [Preorder α]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x) y) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.990 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.990) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1019 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1019 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.992 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.992) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1023 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1023)
 Case conversion may be inaccurate. Consider using '#align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.to_covariantClass_pos_mul_leₓ'. -/
 instance PosMulMono.to_covariantClass_pos_mul_le [PosMulMono α] :
     CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
@@ -162,7 +162,7 @@ instance PosMulMono.to_covariantClass_pos_mul_le [PosMulMono α] :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1116 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1116) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1145 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1145 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1118 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1118) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1149 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1149)
 Case conversion may be inaccurate. Consider using '#align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.to_covariantClass_pos_mul_leₓ'. -/
 instance MulPosMono.to_covariantClass_pos_mul_le [MulPosMono α] :
     CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
@@ -173,7 +173,7 @@ instance MulPosMono.to_covariantClass_pos_mul_le [MulPosMono α] :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x) y) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1242 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1242) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1271 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1271 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1244 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1244) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1275 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1275)
 Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt PosMulReflectLT.to_contravariantClass_pos_mul_ltₓ'. -/
 instance PosMulReflectLT.to_contravariantClass_pos_mul_lt [PosMulReflectLT α] :
     ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
@@ -184,7 +184,7 @@ instance PosMulReflectLT.to_contravariantClass_pos_mul_lt [PosMulReflectLT α] :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1368 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1368) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1397 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1397 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399)
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1370 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1370) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1401 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1401)
 Case conversion may be inaccurate. Consider using '#align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_ltₓ'. -/
 instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
     ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
@@ -799,7 +799,7 @@ variable [PartialOrder α]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4705 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4705) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4734 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4734 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4707 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4707) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4738 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4738))
 Case conversion may be inaccurate. Consider using '#align pos_mul_mono_iff_covariant_pos posMulMono_iff_covariant_posₓ'. -/
 theorem posMulMono_iff_covariant_pos :
     PosMulMono α ↔ CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
@@ -814,7 +814,7 @@ theorem posMulMono_iff_covariant_pos :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4843 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4843) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4872 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4872 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4845 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4845) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4876 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4876))
 Case conversion may be inaccurate. Consider using '#align mul_pos_mono_iff_covariant_pos mulPosMono_iff_covariant_posₓ'. -/
 theorem mulPosMono_iff_covariant_pos :
     MulPosMono α ↔ CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
@@ -829,7 +829,7 @@ theorem mulPosMono_iff_covariant_pos :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4981 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4981) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5010 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5010 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4983 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4983) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5014 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5014))
 Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt_iff_contravariant_pos posMulReflectLT_iff_contravariant_posₓ'. -/
 theorem posMulReflectLT_iff_contravariant_pos :
     PosMulReflectLT α ↔ ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
@@ -844,7 +844,7 @@ theorem posMulReflectLT_iff_contravariant_pos :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5119 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5119) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5148 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5148 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5121 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5121) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5152 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5152))
 Case conversion may be inaccurate. Consider using '#align mul_pos_reflect_lt_iff_contravariant_pos mulPosReflectLT_iff_contravariant_posₓ'. -/
 theorem mulPosReflectLT_iff_contravariant_pos :
     MulPosReflectLT α ↔ ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=

44e29dbc

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -147,193 +147,321 @@ section Preorder
 
 variable [Preorder α]
 
-#print PosMulMono.to_covariantClass_pos_mul_le /-
+/- warning: pos_mul_mono.to_covariant_class_pos_mul_le -> PosMulMono.to_covariantClass_pos_mul_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x) y) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.990 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.990) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1019 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1019 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1021)
+Case conversion may be inaccurate. Consider using '#align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.to_covariantClass_pos_mul_leₓ'. -/
 instance PosMulMono.to_covariantClass_pos_mul_le [PosMulMono α] :
     CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
   ⟨fun a b c bc => @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.to_covariantClass_pos_mul_le
--/
 
-#print MulPosMono.to_covariantClass_pos_mul_le /-
+/- warning: mul_pos_mono.to_covariant_class_pos_mul_le -> MulPosMono.to_covariantClass_pos_mul_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1116 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1116) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1145 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1145 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1147)
+Case conversion may be inaccurate. Consider using '#align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.to_covariantClass_pos_mul_leₓ'. -/
 instance MulPosMono.to_covariantClass_pos_mul_le [MulPosMono α] :
     CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
   ⟨fun a b c bc => @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.to_covariantClass_pos_mul_le
--/
 
-#print PosMulReflectLT.to_contravariantClass_pos_mul_lt /-
+/- warning: pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt -> PosMulReflectLT.to_contravariantClass_pos_mul_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x) y) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1242 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1242) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1271 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1271 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1273)
+Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt PosMulReflectLT.to_contravariantClass_pos_mul_ltₓ'. -/
 instance PosMulReflectLT.to_contravariantClass_pos_mul_lt [PosMulReflectLT α] :
     ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
   ⟨fun a b c bc => @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt PosMulReflectLT.to_contravariantClass_pos_mul_lt
--/
 
-#print MulPosReflectLT.to_contravariantClass_pos_mul_lt /-
+/- warning: mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt -> MulPosReflectLT.to_contravariantClass_pos_mul_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) x))))) x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1368 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1368) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1397 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1397 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.1399)
+Case conversion may be inaccurate. Consider using '#align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_ltₓ'. -/
 instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
     ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
   ⟨fun a b c bc => @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_lt
--/
 
-#print mul_le_mul_of_nonneg_left /-
+/- warning: mul_le_mul_of_nonneg_left -> mul_le_mul_of_nonneg_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
+Case conversion may be inaccurate. Consider using '#align mul_le_mul_of_nonneg_left mul_le_mul_of_nonneg_leftₓ'. -/
 theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c :=
   @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_left mul_le_mul_of_nonneg_left
--/
 
-#print mul_le_mul_of_nonneg_right /-
+/- warning: mul_le_mul_of_nonneg_right -> mul_le_mul_of_nonneg_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
+Case conversion may be inaccurate. Consider using '#align mul_le_mul_of_nonneg_right mul_le_mul_of_nonneg_rightₓ'. -/
 theorem mul_le_mul_of_nonneg_right [MulPosMono α] (h : b ≤ c) (a0 : 0 ≤ a) : b * a ≤ c * a :=
   @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_right mul_le_mul_of_nonneg_right
--/
 
-#print mul_lt_mul_of_pos_left /-
+/- warning: mul_lt_mul_of_pos_left -> mul_lt_mul_of_pos_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_left mul_lt_mul_of_pos_leftₓ'. -/
 theorem mul_lt_mul_of_pos_left [PosMulStrictMono α] (bc : b < c) (a0 : 0 < a) : a * b < a * c :=
   @CovariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_left mul_lt_mul_of_pos_left
--/
 
-#print mul_lt_mul_of_pos_right /-
+/- warning: mul_lt_mul_of_pos_right -> mul_lt_mul_of_pos_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_right mul_lt_mul_of_pos_rightₓ'. -/
 theorem mul_lt_mul_of_pos_right [MulPosStrictMono α] (bc : b < c) (a0 : 0 < a) : b * a < c * a :=
   @CovariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_right mul_lt_mul_of_pos_right
--/
 
-#print lt_of_mul_lt_mul_left /-
+/- warning: lt_of_mul_lt_mul_left -> lt_of_mul_lt_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_left lt_of_mul_lt_mul_leftₓ'. -/
 theorem lt_of_mul_lt_mul_left [PosMulReflectLT α] (h : a * b < a * c) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ h
 #align lt_of_mul_lt_mul_left lt_of_mul_lt_mul_left
--/
 
-#print lt_of_mul_lt_mul_right /-
+/- warning: lt_of_mul_lt_mul_right -> lt_of_mul_lt_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_right lt_of_mul_lt_mul_rightₓ'. -/
 theorem lt_of_mul_lt_mul_right [MulPosReflectLT α] (h : b * a < c * a) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ h
 #align lt_of_mul_lt_mul_right lt_of_mul_lt_mul_right
--/
 
-#print le_of_mul_le_mul_left /-
+/- warning: le_of_mul_le_mul_left -> le_of_mul_le_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_left le_of_mul_le_mul_leftₓ'. -/
 theorem le_of_mul_le_mul_left [PosMulMonoRev α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_left le_of_mul_le_mul_left
--/
 
-#print le_of_mul_le_mul_right /-
+/- warning: le_of_mul_le_mul_right -> le_of_mul_le_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_right le_of_mul_le_mul_rightₓ'. -/
 theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_right le_of_mul_le_mul_right
--/
 
+/- warning: lt_of_mul_lt_mul_of_nonneg_left -> lt_of_mul_lt_mul_of_nonneg_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_leftₓ'. -/
 alias lt_of_mul_lt_mul_left ← lt_of_mul_lt_mul_of_nonneg_left
 #align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_left
 
+/- warning: lt_of_mul_lt_mul_of_nonneg_right -> lt_of_mul_lt_mul_of_nonneg_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_mul_of_nonneg_right lt_of_mul_lt_mul_of_nonneg_rightₓ'. -/
 alias lt_of_mul_lt_mul_right ← lt_of_mul_lt_mul_of_nonneg_right
 #align lt_of_mul_lt_mul_of_nonneg_right lt_of_mul_lt_mul_of_nonneg_right
 
+/- warning: le_of_mul_le_mul_of_pos_left -> le_of_mul_le_mul_of_pos_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_of_pos_left le_of_mul_le_mul_of_pos_leftₓ'. -/
 alias le_of_mul_le_mul_left ← le_of_mul_le_mul_of_pos_left
 #align le_of_mul_le_mul_of_pos_left le_of_mul_le_mul_of_pos_left
 
+/- warning: le_of_mul_le_mul_of_pos_right -> le_of_mul_le_mul_of_pos_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
+Case conversion may be inaccurate. Consider using '#align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_rightₓ'. -/
 alias le_of_mul_le_mul_right ← le_of_mul_le_mul_of_pos_right
 #align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_right
 
-#print mul_lt_mul_left /-
+/- warning: mul_lt_mul_left -> mul_lt_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_left mul_lt_mul_leftₓ'. -/
 @[simp]
 theorem mul_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a * b < a * c ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· < ·) _ _ ⟨a, a0⟩ _ _
 #align mul_lt_mul_left mul_lt_mul_left
--/
 
-#print mul_lt_mul_right /-
+/- warning: mul_lt_mul_right -> mul_lt_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_right mul_lt_mul_rightₓ'. -/
 @[simp]
 theorem mul_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a) :
     b * a < c * a ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· < ·) _ _ ⟨a, a0⟩ _ _
 #align mul_lt_mul_right mul_lt_mul_right
--/
 
-#print mul_le_mul_left /-
+/- warning: mul_le_mul_left -> mul_le_mul_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c))
+Case conversion may be inaccurate. Consider using '#align mul_le_mul_left mul_le_mul_leftₓ'. -/
 @[simp]
 theorem mul_le_mul_left [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_left mul_le_mul_left
--/
 
-#print mul_le_mul_right /-
+/- warning: mul_le_mul_right -> mul_le_mul_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) c a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c))
+Case conversion may be inaccurate. Consider using '#align mul_le_mul_right mul_le_mul_rightₓ'. -/
 @[simp]
 theorem mul_le_mul_right [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_right mul_le_mul_right
--/
 
-#print mul_lt_mul_of_pos_of_nonneg /-
+/- warning: mul_lt_mul_of_pos_of_nonneg -> mul_lt_mul_of_pos_of_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_of_nonneg mul_lt_mul_of_pos_of_nonnegₓ'. -/
 theorem mul_lt_mul_of_pos_of_nonneg [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 ≤ d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans_le (mul_le_mul_of_nonneg_right h₁ d0)
 #align mul_lt_mul_of_pos_of_nonneg mul_lt_mul_of_pos_of_nonneg
--/
 
-#print mul_lt_mul_of_le_of_le' /-
+/- warning: mul_lt_mul_of_le_of_le' -> mul_lt_mul_of_le_of_le' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_le_of_le' mul_lt_mul_of_le_of_le'ₓ'. -/
 theorem mul_lt_mul_of_le_of_le' [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 ≤ c) : a * c < b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans_lt (mul_lt_mul_of_pos_left h₂ b0)
 #align mul_lt_mul_of_le_of_le' mul_lt_mul_of_le_of_le'
--/
 
-#print mul_lt_mul_of_nonneg_of_pos /-
+/- warning: mul_lt_mul_of_nonneg_of_pos -> mul_lt_mul_of_nonneg_of_pos is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_nonneg_of_pos mul_lt_mul_of_nonneg_of_posₓ'. -/
 theorem mul_lt_mul_of_nonneg_of_pos [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (a0 : 0 ≤ a) (d0 : 0 < d) : a * c < b * d :=
   (mul_le_mul_of_nonneg_left h₂ a0).trans_lt (mul_lt_mul_of_pos_right h₁ d0)
 #align mul_lt_mul_of_nonneg_of_pos mul_lt_mul_of_nonneg_of_pos
--/
 
-#print mul_lt_mul_of_le_of_lt' /-
+/- warning: mul_lt_mul_of_le_of_lt' -> mul_lt_mul_of_le_of_lt' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_le_of_lt' mul_lt_mul_of_le_of_lt'ₓ'. -/
 theorem mul_lt_mul_of_le_of_lt' [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (b0 : 0 ≤ b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans_le (mul_le_mul_of_nonneg_left h₂ b0)
 #align mul_lt_mul_of_le_of_lt' mul_lt_mul_of_le_of_lt'
--/
 
-#print mul_lt_mul_of_pos_of_pos /-
+/- warning: mul_lt_mul_of_pos_of_pos -> mul_lt_mul_of_pos_of_pos is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_pos_of_pos mul_lt_mul_of_pos_of_posₓ'. -/
 theorem mul_lt_mul_of_pos_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 < d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans (mul_lt_mul_of_pos_right h₁ d0)
 #align mul_lt_mul_of_pos_of_pos mul_lt_mul_of_pos_of_pos
--/
 
-#print mul_lt_mul_of_lt_of_lt' /-
+/- warning: mul_lt_mul_of_lt_of_lt' -> mul_lt_mul_of_lt_of_lt' is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α _inst_1 _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_of_lt_of_lt' mul_lt_mul_of_lt_of_lt'ₓ'. -/
 theorem mul_lt_mul_of_lt_of_lt' [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans (mul_lt_mul_of_pos_left h₂ b0)
 #align mul_lt_mul_of_lt_of_lt' mul_lt_mul_of_lt_of_lt'
--/
 
-#print mul_lt_of_mul_lt_of_nonneg_left /-
+/- warning: mul_lt_of_mul_lt_of_nonneg_left -> mul_lt_of_mul_lt_of_nonneg_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) d b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a d) c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) d b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a d) c)
+Case conversion may be inaccurate. Consider using '#align mul_lt_of_mul_lt_of_nonneg_left mul_lt_of_mul_lt_of_nonneg_leftₓ'. -/
 theorem mul_lt_of_mul_lt_of_nonneg_left [PosMulMono α] (h : a * b < c) (hdb : d ≤ b) (ha : 0 ≤ a) :
     a * d < c :=
   (mul_le_mul_of_nonneg_left hdb ha).trans_lt h
 #align mul_lt_of_mul_lt_of_nonneg_left mul_lt_of_mul_lt_of_nonneg_left
--/
 
-#print lt_mul_of_lt_mul_of_nonneg_left /-
+/- warning: lt_mul_of_lt_mul_of_nonneg_left -> lt_mul_of_lt_mul_of_nonneg_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b d))
+Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_mul_of_nonneg_left lt_mul_of_lt_mul_of_nonneg_leftₓ'. -/
 theorem lt_mul_of_lt_mul_of_nonneg_left [PosMulMono α] (h : a < b * c) (hcd : c ≤ d) (hb : 0 ≤ b) :
     a < b * d :=
   h.trans_le <| mul_le_mul_of_nonneg_left hcd hb
 #align lt_mul_of_lt_mul_of_nonneg_left lt_mul_of_lt_mul_of_nonneg_left
--/
 
-#print mul_lt_of_mul_lt_of_nonneg_right /-
+/- warning: mul_lt_of_mul_lt_of_nonneg_right -> mul_lt_of_mul_lt_of_nonneg_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) d a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d b) c)
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) d a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d b) c)
+Case conversion may be inaccurate. Consider using '#align mul_lt_of_mul_lt_of_nonneg_right mul_lt_of_mul_lt_of_nonneg_rightₓ'. -/
 theorem mul_lt_of_mul_lt_of_nonneg_right [MulPosMono α] (h : a * b < c) (hda : d ≤ a) (hb : 0 ≤ b) :
     d * b < c :=
   (mul_le_mul_of_nonneg_right hda hb).trans_lt h
 #align mul_lt_of_mul_lt_of_nonneg_right mul_lt_of_mul_lt_of_nonneg_right
--/
 
-#print lt_mul_of_lt_mul_of_nonneg_right /-
+/- warning: lt_mul_of_lt_mul_of_nonneg_right -> lt_mul_of_lt_mul_of_nonneg_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d c))
+but is expected to have type
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : Mul.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α _inst_1 _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_1) d c))
+Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_mul_of_nonneg_right lt_mul_of_lt_mul_of_nonneg_rightₓ'. -/
 theorem lt_mul_of_lt_mul_of_nonneg_right [MulPosMono α] (h : a < b * c) (hbd : b ≤ d) (hc : 0 ≤ c) :
     a < d * c :=
   h.trans_le <| mul_le_mul_of_nonneg_right hbd hc
 #align lt_mul_of_lt_mul_of_nonneg_right lt_mul_of_lt_mul_of_nonneg_right
--/
 
 end Preorder
 
@@ -427,7 +555,7 @@ variable [Preorder α]
 
 /- warning: left.mul_pos -> Left.mul_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align left.mul_pos Left.mul_posₓ'. -/
@@ -438,7 +566,7 @@ theorem Left.mul_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b
 
 /- warning: mul_pos -> mul_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align mul_pos mul_posₓ'. -/
@@ -447,7 +575,7 @@ alias Left.mul_pos ← mul_pos
 
 /- warning: mul_neg_of_pos_of_neg -> mul_neg_of_pos_of_neg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_neg_of_pos_of_neg mul_neg_of_pos_of_negₓ'. -/
@@ -457,7 +585,7 @@ theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) :
 
 /- warning: zero_lt_mul_left -> zero_lt_mul_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) c b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
+  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) c b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
 but is expected to have type
   forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) c b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b))
 Case conversion may be inaccurate. Consider using '#align zero_lt_mul_left zero_lt_mul_leftₓ'. -/
@@ -470,7 +598,7 @@ theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c)
 
 /- warning: right.mul_pos -> Right.mul_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align right.mul_pos Right.mul_posₓ'. -/
@@ -481,7 +609,7 @@ theorem Right.mul_pos [MulPosStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a *
 
 /- warning: mul_neg_of_neg_of_pos -> mul_neg_of_neg_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_neg_of_neg_of_pos mul_neg_of_neg_of_posₓ'. -/
@@ -491,7 +619,7 @@ theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) :
 
 /- warning: zero_lt_mul_right -> zero_lt_mul_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
+  forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
 but is expected to have type
   forall {α : Type.{u1}} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b c)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b))
 Case conversion may be inaccurate. Consider using '#align zero_lt_mul_right zero_lt_mul_rightₓ'. -/
@@ -504,7 +632,7 @@ theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c)
 
 /- warning: left.mul_nonneg -> Left.mul_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align left.mul_nonneg Left.mul_nonnegₓ'. -/
@@ -515,7 +643,7 @@ theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a
 
 /- warning: mul_nonneg -> mul_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align mul_nonneg mul_nonnegₓ'. -/
@@ -524,7 +652,7 @@ alias Left.mul_nonneg ← mul_nonneg
 
 /- warning: mul_nonpos_of_nonneg_of_nonpos -> mul_nonpos_of_nonneg_of_nonpos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_nonpos_of_nonneg_of_nonpos mul_nonpos_of_nonneg_of_nonposₓ'. -/
@@ -534,7 +662,7 @@ theorem mul_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b 
 
 /- warning: right.mul_nonneg -> Right.mul_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align right.mul_nonneg Right.mul_nonnegₓ'. -/
@@ -545,7 +673,7 @@ theorem Right.mul_nonneg [MulPosMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a
 
 /- warning: mul_nonpos_of_nonpos_of_nonneg -> mul_nonpos_of_nonpos_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_nonpos_of_nonpos_of_nonneg mul_nonpos_of_nonpos_of_nonnegₓ'. -/
@@ -555,7 +683,7 @@ theorem mul_nonpos_of_nonpos_of_nonneg [MulPosMono α] (ha : a ≤ 0) (hb : 0 
 
 /- warning: pos_of_mul_pos_right -> pos_of_mul_pos_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b)
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b)
 Case conversion may be inaccurate. Consider using '#align pos_of_mul_pos_right pos_of_mul_pos_rightₓ'. -/
@@ -565,7 +693,7 @@ theorem pos_of_mul_pos_right [PosMulReflectLT α] (h : 0 < a * b) (ha : 0 ≤ a)
 
 /- warning: pos_of_mul_pos_left -> pos_of_mul_pos_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a)
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a)
 Case conversion may be inaccurate. Consider using '#align pos_of_mul_pos_left pos_of_mul_pos_leftₓ'. -/
@@ -575,7 +703,7 @@ theorem pos_of_mul_pos_left [MulPosReflectLT α] (h : 0 < a * b) (hb : 0 ≤ b)
 
 /- warning: pos_iff_pos_of_mul_pos -> pos_iff_pos_of_mul_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b))
 Case conversion may be inaccurate. Consider using '#align pos_iff_pos_of_mul_pos pos_iff_pos_of_mul_posₓ'. -/
@@ -586,7 +714,7 @@ theorem pos_iff_pos_of_mul_pos [PosMulReflectLT α] [MulPosReflectLT α] (hab :
 
 /- warning: mul_le_mul_of_le_of_le -> mul_le_mul_of_le_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d))
 Case conversion may be inaccurate. Consider using '#align mul_le_mul_of_le_of_le mul_le_mul_of_le_of_leₓ'. -/
@@ -597,7 +725,7 @@ theorem mul_le_mul_of_le_of_le [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b)
 
 /- warning: mul_le_mul -> mul_le_mul is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (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) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d))
 Case conversion may be inaccurate. Consider using '#align mul_le_mul mul_le_mulₓ'. -/
@@ -608,7 +736,7 @@ theorem mul_le_mul [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c 
 
 /- warning: mul_self_le_mul_self -> mul_self_le_mul_self is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a a) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b b))
 Case conversion may be inaccurate. Consider using '#align mul_self_le_mul_self mul_self_le_mul_selfₓ'. -/
@@ -619,7 +747,7 @@ theorem mul_self_le_mul_self [PosMulMono α] [MulPosMono α] (ha : 0 ≤ a) (hab
 
 /- warning: mul_le_of_mul_le_of_nonneg_left -> mul_le_of_mul_le_of_nonneg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) d b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a d) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) d b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a d) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) d b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a d) c)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_mul_le_of_nonneg_left mul_le_of_mul_le_of_nonneg_leftₓ'. -/
@@ -630,7 +758,7 @@ theorem mul_le_of_mul_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hle :
 
 /- warning: le_mul_of_le_mul_of_nonneg_left -> le_mul_of_le_mul_of_nonneg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) c d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d))
 Case conversion may be inaccurate. Consider using '#align le_mul_of_le_mul_of_nonneg_left le_mul_of_le_mul_of_nonneg_leftₓ'. -/
@@ -641,7 +769,7 @@ theorem le_mul_of_le_mul_of_nonneg_left [PosMulMono α] (h : a ≤ b * c) (hle :
 
 /- warning: mul_le_of_mul_le_of_nonneg_right -> mul_le_of_mul_le_of_nonneg_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) d a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) d b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) d a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) d b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) d a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) d b) c)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_mul_le_of_nonneg_right mul_le_of_mul_le_of_nonneg_rightₓ'. -/
@@ -652,7 +780,7 @@ theorem mul_le_of_mul_le_of_nonneg_right [MulPosMono α] (h : a * b ≤ c) (hle
 
 /- warning: le_mul_of_le_mul_of_nonneg_right -> le_mul_of_le_mul_of_nonneg_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) b d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) d c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) b d) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) d c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) b d) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) d c))
 Case conversion may be inaccurate. Consider using '#align le_mul_of_le_mul_of_nonneg_right le_mul_of_le_mul_of_nonneg_rightₓ'. -/
@@ -669,7 +797,7 @@ variable [PartialOrder α]
 
 /- warning: pos_mul_mono_iff_covariant_pos -> posMulMono_iff_covariant_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4705 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4705) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4734 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4734 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4736))
 Case conversion may be inaccurate. Consider using '#align pos_mul_mono_iff_covariant_pos posMulMono_iff_covariant_posₓ'. -/
@@ -684,7 +812,7 @@ theorem posMulMono_iff_covariant_pos :
 
 /- warning: mul_pos_mono_iff_covariant_pos -> mulPosMono_iff_covariant_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (CovariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4843 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4843) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4872 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4872 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4874))
 Case conversion may be inaccurate. Consider using '#align mul_pos_mono_iff_covariant_pos mulPosMono_iff_covariant_posₓ'. -/
@@ -699,7 +827,7 @@ theorem mulPosMono_iff_covariant_pos :
 
 /- warning: pos_mul_reflect_lt_iff_contravariant_pos -> posMulReflectLT_iff_contravariant_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x) y) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4981 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.4981) x) y) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5010 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5010 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5012))
 Case conversion may be inaccurate. Consider using '#align pos_mul_reflect_lt_iff_contravariant_pos posMulReflectLT_iff_contravariant_posₓ'. -/
@@ -714,7 +842,7 @@ theorem posMulReflectLT_iff_contravariant_pos :
 
 /- warning: mul_pos_reflect_lt_iff_contravariant_pos -> mulPosReflectLT_iff_contravariant_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
+  forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) y ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (HasLiftT.mk.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (CoeTCₓ.coe.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeBase.{succ u1, succ u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x)) α (coeSubtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) x))))) x)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α], Iff (MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)) (ContravariantClass.{u1, u1} (Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) α (fun (x : Subtype.{succ u1} α (fun (x : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x)) (y : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) y (Subtype.val.{succ u1} α (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5119 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5119) x)) (fun (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5148 : α) (x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5148 x._@.Mathlib.Algebra.Order.Ring.Lemmas._hyg.5150))
 Case conversion may be inaccurate. Consider using '#align mul_pos_reflect_lt_iff_contravariant_pos mulPosReflectLT_iff_contravariant_posₓ'. -/
@@ -785,7 +913,7 @@ instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] :
 
 /- warning: mul_left_cancel_iff_of_pos -> mul_left_cancel_iff_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c)) (Eq.{succ u1} α b c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c)) (Eq.{succ u1} α b c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c)) (Eq.{succ u1} α b c))
 Case conversion may be inaccurate. Consider using '#align mul_left_cancel_iff_of_pos mul_left_cancel_iff_of_posₓ'. -/
@@ -796,7 +924,7 @@ theorem mul_left_cancel_iff_of_pos [PosMulMonoRev α] (a0 : 0 < a) : a * b = a *
 
 /- warning: mul_right_cancel_iff_of_pos -> mul_right_cancel_iff_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) c b)) (Eq.{succ u1} α a c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) c b)) (Eq.{succ u1} α a c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) c b)) (Eq.{succ u1} α a c))
 Case conversion may be inaccurate. Consider using '#align mul_right_cancel_iff_of_pos mul_right_cancel_iff_of_posₓ'. -/
@@ -808,7 +936,7 @@ theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c
 
 /- warning: mul_eq_mul_iff_eq_and_eq_of_pos -> mul_eq_mul_iff_eq_and_eq_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) d) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) d) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) d) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
 Case conversion may be inaccurate. Consider using '#align mul_eq_mul_iff_eq_and_eq_of_pos mul_eq_mul_iff_eq_and_eq_of_posₓ'. -/
@@ -826,7 +954,7 @@ theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono
 
 /- warning: mul_eq_mul_iff_eq_and_eq_of_pos' -> mul_eq_mul_iff_eq_and_eq_of_pos' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) c) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} {d : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_4 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_5 : PosMulMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)] [_inst_6 : MulPosMonoRev.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α _inst_2)], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) c d) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) c) -> (Iff (Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) b d)) (And (Eq.{succ u1} α a b) (Eq.{succ u1} α c d)))
 Case conversion may be inaccurate. Consider using '#align mul_eq_mul_iff_eq_and_eq_of_pos' mul_eq_mul_iff_eq_and_eq_of_pos'ₓ'. -/
@@ -850,7 +978,7 @@ variable [LinearOrder α]
 
 /- warning: pos_and_pos_or_neg_and_neg_of_mul_pos -> pos_and_pos_or_neg_and_neg_of_mul_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Or (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Or (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b)) (And (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (Or (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b)) (And (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))))
 Case conversion may be inaccurate. Consider using '#align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_posₓ'. -/
@@ -868,7 +996,7 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
 
 /- warning: neg_of_mul_pos_right -> neg_of_mul_pos_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align neg_of_mul_pos_right neg_of_mul_pos_rightₓ'. -/
@@ -878,7 +1006,7 @@ theorem neg_of_mul_pos_right [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha
 
 /- warning: neg_of_mul_pos_left -> neg_of_mul_pos_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align neg_of_mul_pos_left neg_of_mul_pos_leftₓ'. -/
@@ -888,7 +1016,7 @@ theorem neg_of_mul_pos_left [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha
 
 /- warning: neg_iff_neg_of_mul_pos -> neg_iff_neg_of_mul_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))] [_inst_4 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align neg_iff_neg_of_mul_pos neg_iff_neg_of_mul_posₓ'. -/
@@ -898,7 +1026,7 @@ theorem neg_iff_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b)
 
 /- warning: left.neg_of_mul_neg_left -> Left.neg_of_mul_neg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align left.neg_of_mul_neg_left Left.neg_of_mul_neg_leftₓ'. -/
@@ -908,7 +1036,7 @@ theorem Left.neg_of_mul_neg_left [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ a)
 
 /- warning: right.neg_of_mul_neg_left -> Right.neg_of_mul_neg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align right.neg_of_mul_neg_left Right.neg_of_mul_neg_leftₓ'. -/
@@ -918,7 +1046,7 @@ theorem Right.neg_of_mul_neg_left [MulPosMono α] (h : a * b < 0) (h1 : 0 ≤ a)
 
 /- warning: left.neg_of_mul_neg_right -> Left.neg_of_mul_neg_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align left.neg_of_mul_neg_right Left.neg_of_mul_neg_rightₓ'. -/
@@ -928,7 +1056,7 @@ theorem Left.neg_of_mul_neg_right [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ b)
 
 /- warning: right.neg_of_mul_neg_right -> Right.neg_of_mul_neg_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1) (MulZeroClass.toHasZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α (MulZeroClass.toHasZero.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : LinearOrder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_2))) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align right.neg_of_mul_neg_right Right.neg_of_mul_neg_rightₓ'. -/
@@ -954,7 +1082,7 @@ which assume left covariance. -/
 
 /- warning: le_mul_iff_one_le_right -> le_mul_iff_one_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
 Case conversion may be inaccurate. Consider using '#align le_mul_iff_one_le_right le_mul_iff_one_le_rightₓ'. -/
@@ -965,7 +1093,7 @@ theorem le_mul_iff_one_le_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a)
 
 /- warning: lt_mul_iff_one_lt_right -> lt_mul_iff_one_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
 Case conversion may be inaccurate. Consider using '#align lt_mul_iff_one_lt_right lt_mul_iff_one_lt_rightₓ'. -/
@@ -977,7 +1105,7 @@ theorem lt_mul_iff_one_lt_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 :
 
 /- warning: mul_le_iff_le_one_right -> mul_le_iff_le_one_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align mul_le_iff_le_one_right mul_le_iff_le_one_rightₓ'. -/
@@ -988,7 +1116,7 @@ theorem mul_le_iff_le_one_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a)
 
 /- warning: mul_lt_iff_lt_one_right -> mul_lt_iff_lt_one_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : PosMulReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align mul_lt_iff_lt_one_right mul_lt_iff_lt_one_rightₓ'. -/
@@ -1004,7 +1132,7 @@ which assume right covariance. -/
 
 /- warning: le_mul_iff_one_le_left -> le_mul_iff_one_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
 Case conversion may be inaccurate. Consider using '#align le_mul_iff_one_le_left le_mul_iff_one_le_leftₓ'. -/
@@ -1015,7 +1143,7 @@ theorem le_mul_iff_one_le_left [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) :
 
 /- warning: lt_mul_iff_one_lt_left -> lt_mul_iff_one_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b))
 Case conversion may be inaccurate. Consider using '#align lt_mul_iff_one_lt_left lt_mul_iff_one_lt_leftₓ'. -/
@@ -1027,7 +1155,7 @@ theorem lt_mul_iff_one_lt_left [MulPosStrictMono α] [MulPosReflectLT α] (a0 :
 
 /- warning: mul_le_iff_le_one_left -> mul_le_iff_le_one_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMonoRev.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align mul_le_iff_le_one_left mul_le_iff_le_one_leftₓ'. -/
@@ -1038,7 +1166,7 @@ theorem mul_le_iff_le_one_left [MulPosMono α] [MulPosMonoRev α] (b0 : 0 < b) :
 
 /- warning: mul_lt_iff_lt_one_left -> mul_lt_iff_lt_one_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosReflectLT.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))))
 Case conversion may be inaccurate. Consider using '#align mul_lt_iff_lt_one_left mul_lt_iff_lt_one_leftₓ'. -/
@@ -1056,7 +1184,7 @@ imports this file) as they need additional results which are not yet available h
 
 /- warning: mul_le_of_le_one_left -> mul_le_of_le_one_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b)
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_left mul_le_of_le_one_leftₓ'. -/
@@ -1066,7 +1194,7 @@ theorem mul_le_of_le_one_left [MulPosMono α] (hb : 0 ≤ b) (h : a ≤ 1) : a *
 
 /- warning: le_mul_of_one_le_left -> le_mul_of_one_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align le_mul_of_one_le_left le_mul_of_one_le_leftₓ'. -/
@@ -1076,7 +1204,7 @@ theorem le_mul_of_one_le_left [MulPosMono α] (hb : 0 ≤ b) (h : 1 ≤ a) : b 
 
 /- warning: mul_le_of_le_one_right -> mul_le_of_le_one_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a)
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_right mul_le_of_le_one_rightₓ'. -/
@@ -1086,7 +1214,7 @@ theorem mul_le_of_le_one_right [PosMulMono α] (ha : 0 ≤ a) (h : b ≤ 1) : a
 
 /- warning: le_mul_of_one_le_right -> le_mul_of_one_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align le_mul_of_one_le_right le_mul_of_one_le_rightₓ'. -/
@@ -1096,7 +1224,7 @@ theorem le_mul_of_one_le_right [PosMulMono α] (ha : 0 ≤ a) (h : 1 ≤ b) : a
 
 /- warning: mul_lt_of_lt_one_left -> mul_lt_of_lt_one_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b)
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) b)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_left mul_lt_of_lt_one_leftₓ'. -/
@@ -1106,7 +1234,7 @@ theorem mul_lt_of_lt_one_left [MulPosStrictMono α] (hb : 0 < b) (h : a < 1) : a
 
 /- warning: lt_mul_of_one_lt_left -> lt_mul_of_one_lt_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_left lt_mul_of_one_lt_leftₓ'. -/
@@ -1116,7 +1244,7 @@ theorem lt_mul_of_one_lt_left [MulPosStrictMono α] (hb : 0 < b) (h : 1 < a) : b
 
 /- warning: mul_lt_of_lt_one_right -> mul_lt_of_lt_one_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a)
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) a)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) a)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_right mul_lt_of_lt_one_rightₓ'. -/
@@ -1126,7 +1254,7 @@ theorem mul_lt_of_lt_one_right [PosMulStrictMono α] (ha : 0 < a) (h : b < 1) :
 
 /- warning: lt_mul_of_one_lt_right -> lt_mul_of_one_lt_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_right lt_mul_of_one_lt_rightₓ'. -/
@@ -1139,7 +1267,7 @@ theorem lt_mul_of_one_lt_right [PosMulStrictMono α] (ha : 0 < a) (h : 1 < b) :
 
 /- warning: mul_le_of_le_of_le_one_of_nonneg -> mul_le_of_le_of_le_one_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_le_of_le_one_of_nonneg mul_le_of_le_of_le_one_of_nonnegₓ'. -/
@@ -1153,7 +1281,7 @@ theorem mul_le_of_le_of_le_one_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : a 
 
 /- warning: mul_lt_of_le_of_lt_one_of_pos -> mul_lt_of_le_of_lt_one_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_of_lt_one_of_pos mul_lt_of_le_of_lt_one_of_posₓ'. -/
@@ -1164,7 +1292,7 @@ theorem mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha :
 
 /- warning: mul_lt_of_lt_of_le_one_of_nonneg -> mul_lt_of_lt_of_le_one_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_of_le_one_of_nonneg mul_lt_of_lt_of_le_one_of_nonnegₓ'. -/
@@ -1175,7 +1303,7 @@ theorem mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (h : b < c) (ha : a ≤
 
 /- warning: left.mul_le_one_of_le_of_le -> Left.mul_le_one_of_le_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align left.mul_le_one_of_le_of_le Left.mul_le_one_of_le_of_leₓ'. -/
@@ -1187,7 +1315,7 @@ theorem Left.mul_le_one_of_le_of_le [PosMulMono α] (ha : a ≤ 1) (hb : b ≤ 1
 
 /- warning: left.mul_lt_of_le_of_lt_one_of_pos -> Left.mul_lt_of_le_of_lt_one_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align left.mul_lt_of_le_of_lt_one_of_pos Left.mul_lt_of_le_of_lt_one_of_posₓ'. -/
@@ -1199,7 +1327,7 @@ theorem Left.mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (ha : a ≤ 1)
 
 /- warning: left.mul_lt_of_lt_of_le_one_of_nonneg -> Left.mul_lt_of_lt_of_le_one_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align left.mul_lt_of_lt_of_le_one_of_nonneg Left.mul_lt_of_lt_of_le_one_of_nonnegₓ'. -/
@@ -1211,7 +1339,7 @@ theorem Left.mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (ha : a < 1) (hb :
 
 /- warning: mul_le_of_le_of_le_one' -> mul_le_of_le_of_le_one' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_le_of_le_one' mul_le_of_le_of_le_one'ₓ'. -/
@@ -1222,7 +1350,7 @@ theorem mul_le_of_le_of_le_one' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (
 
 /- warning: mul_lt_of_lt_of_le_one' -> mul_lt_of_lt_of_le_one' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_of_le_one' mul_lt_of_lt_of_le_one'ₓ'. -/
@@ -1233,7 +1361,7 @@ theorem mul_lt_of_lt_of_le_one' [PosMulMono α] [MulPosStrictMono α] (bc : b <
 
 /- warning: mul_lt_of_le_of_lt_one' -> mul_lt_of_le_of_lt_one' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_of_lt_one' mul_lt_of_le_of_lt_one'ₓ'. -/
@@ -1244,7 +1372,7 @@ theorem mul_lt_of_le_of_lt_one' [PosMulStrictMono α] [MulPosMono α] (bc : b 
 
 /- warning: mul_lt_of_lt_of_lt_one_of_pos -> mul_lt_of_lt_of_lt_one_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b a) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b a) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_of_lt_one_of_pos mul_lt_of_lt_of_lt_one_of_posₓ'. -/
@@ -1258,7 +1386,7 @@ theorem mul_lt_of_lt_of_lt_one_of_pos [PosMulMono α] [MulPosStrictMono α] (bc
 
 /- warning: le_mul_of_le_of_one_le_of_nonneg -> le_mul_of_le_of_one_le_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align le_mul_of_le_of_one_le_of_nonneg le_mul_of_le_of_one_le_of_nonnegₓ'. -/
@@ -1269,7 +1397,7 @@ theorem le_mul_of_le_of_one_le_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : 1 
 
 /- warning: lt_mul_of_le_of_one_lt_of_pos -> lt_mul_of_le_of_one_lt_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_le_of_one_lt_of_pos lt_mul_of_le_of_one_lt_of_posₓ'. -/
@@ -1280,7 +1408,7 @@ theorem lt_mul_of_le_of_one_lt_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha :
 
 /- warning: lt_mul_of_lt_of_one_le_of_nonneg -> lt_mul_of_lt_of_one_le_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_of_one_le_of_nonneg lt_mul_of_lt_of_one_le_of_nonnegₓ'. -/
@@ -1291,7 +1419,7 @@ theorem lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (h : b < c) (ha : 1 ≤
 
 /- warning: left.one_le_mul_of_le_of_le -> Left.one_le_mul_of_le_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align left.one_le_mul_of_le_of_le Left.one_le_mul_of_le_of_leₓ'. -/
@@ -1303,7 +1431,7 @@ theorem Left.one_le_mul_of_le_of_le [PosMulMono α] (ha : 1 ≤ a) (hb : 1 ≤ b
 
 /- warning: left.one_lt_mul_of_le_of_lt_of_pos -> Left.one_lt_mul_of_le_of_lt_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align left.one_lt_mul_of_le_of_lt_of_pos Left.one_lt_mul_of_le_of_lt_of_posₓ'. -/
@@ -1315,7 +1443,7 @@ theorem Left.one_lt_mul_of_le_of_lt_of_pos [PosMulStrictMono α] (ha : 1 ≤ a)
 
 /- warning: left.lt_mul_of_lt_of_one_le_of_nonneg -> Left.lt_mul_of_lt_of_one_le_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align left.lt_mul_of_lt_of_one_le_of_nonneg Left.lt_mul_of_lt_of_one_le_of_nonnegₓ'. -/
@@ -1327,7 +1455,7 @@ theorem Left.lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (ha : 1 < a) (hb :
 
 /- warning: le_mul_of_le_of_one_le' -> le_mul_of_le_of_one_le' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align le_mul_of_le_of_one_le' le_mul_of_le_of_one_le'ₓ'. -/
@@ -1338,7 +1466,7 @@ theorem le_mul_of_le_of_one_le' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (
 
 /- warning: lt_mul_of_le_of_one_lt' -> lt_mul_of_le_of_one_lt' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_le_of_one_lt' lt_mul_of_le_of_one_lt'ₓ'. -/
@@ -1349,7 +1477,7 @@ theorem lt_mul_of_le_of_one_lt' [PosMulStrictMono α] [MulPosMono α] (bc : b 
 
 /- warning: lt_mul_of_lt_of_one_le' -> lt_mul_of_lt_of_one_le' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_of_one_le' lt_mul_of_lt_of_one_le'ₓ'. -/
@@ -1360,7 +1488,7 @@ theorem lt_mul_of_lt_of_one_le' [PosMulMono α] [MulPosStrictMono α] (bc : b <
 
 /- warning: lt_mul_of_lt_of_one_lt_of_pos -> lt_mul_of_lt_of_one_lt_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) c a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) c a))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_lt_of_one_lt_of_pos lt_mul_of_lt_of_one_lt_of_posₓ'. -/
@@ -1374,7 +1502,7 @@ theorem lt_mul_of_lt_of_one_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α
 
 /- warning: mul_le_of_le_one_of_le_of_nonneg -> mul_le_of_le_one_of_le_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_of_le_of_nonneg mul_le_of_le_one_of_le_of_nonnegₓ'. -/
@@ -1385,7 +1513,7 @@ theorem mul_le_of_le_one_of_le_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b 
 
 /- warning: mul_lt_of_lt_one_of_le_of_pos -> mul_lt_of_lt_one_of_le_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_of_le_of_pos mul_lt_of_lt_one_of_le_of_posₓ'. -/
@@ -1396,7 +1524,7 @@ theorem mul_lt_of_lt_one_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (h : b
 
 /- warning: mul_lt_of_le_one_of_lt_of_nonneg -> mul_lt_of_le_one_of_lt_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_one_of_lt_of_nonneg mul_lt_of_le_one_of_lt_of_nonnegₓ'. -/
@@ -1407,7 +1535,7 @@ theorem mul_lt_of_le_one_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b <
 
 /- warning: right.mul_lt_one_of_lt_of_le_of_pos -> Right.mul_lt_one_of_lt_of_le_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align right.mul_lt_one_of_lt_of_le_of_pos Right.mul_lt_one_of_lt_of_le_of_posₓ'. -/
@@ -1419,7 +1547,7 @@ theorem Right.mul_lt_one_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (
 
 /- warning: right.mul_lt_one_of_le_of_lt_of_nonneg -> Right.mul_lt_one_of_le_of_lt_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align right.mul_lt_one_of_le_of_lt_of_nonneg Right.mul_lt_one_of_le_of_lt_of_nonnegₓ'. -/
@@ -1431,7 +1559,7 @@ theorem Right.mul_lt_one_of_le_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h
 
 /- warning: mul_lt_of_lt_one_of_lt_of_pos -> mul_lt_of_lt_one_of_lt_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_of_lt_of_pos mul_lt_of_lt_one_of_lt_of_posₓ'. -/
@@ -1442,7 +1570,7 @@ theorem mul_lt_of_lt_one_of_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α
 
 /- warning: right.mul_le_one_of_le_of_le -> Right.mul_le_one_of_le_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align right.mul_le_one_of_le_of_le Right.mul_le_one_of_le_of_leₓ'. -/
@@ -1454,7 +1582,7 @@ theorem Right.mul_le_one_of_le_of_le [MulPosMono α] (ha : a ≤ 1) (hb : b ≤
 
 /- warning: mul_le_of_le_one_of_le' -> mul_le_of_le_one_of_le' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
 Case conversion may be inaccurate. Consider using '#align mul_le_of_le_one_of_le' mul_le_of_le_one_of_le'ₓ'. -/
@@ -1465,7 +1593,7 @@ theorem mul_le_of_le_one_of_le' [PosMulMono α] [MulPosMono α] (ha : a ≤ 1) (
 
 /- warning: mul_lt_of_lt_one_of_le' -> mul_lt_of_lt_one_of_le' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_lt_one_of_le' mul_lt_of_lt_one_of_le'ₓ'. -/
@@ -1476,7 +1604,7 @@ theorem mul_lt_of_lt_one_of_le' [PosMulMono α] [MulPosStrictMono α] (ha : a <
 
 /- warning: mul_lt_of_le_one_of_lt' -> mul_lt_of_le_one_of_lt' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3] [_inst_5 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c)
 Case conversion may be inaccurate. Consider using '#align mul_lt_of_le_one_of_lt' mul_lt_of_le_one_of_lt'ₓ'. -/
@@ -1490,7 +1618,7 @@ theorem mul_lt_of_le_one_of_lt' [PosMulStrictMono α] [MulPosMono α] (ha : a 
 
 /- warning: lt_mul_of_one_lt_of_le_of_pos -> lt_mul_of_one_lt_of_le_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_of_le_of_pos lt_mul_of_one_lt_of_le_of_posₓ'. -/
@@ -1501,7 +1629,7 @@ theorem lt_mul_of_one_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b
 
 /- warning: lt_mul_of_one_le_of_lt_of_nonneg -> lt_mul_of_one_le_of_lt_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_le_of_lt_of_nonneg lt_mul_of_one_le_of_lt_of_nonnegₓ'. -/
@@ -1512,7 +1640,7 @@ theorem lt_mul_of_one_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b <
 
 /- warning: lt_mul_of_one_lt_of_lt_of_pos -> lt_mul_of_one_lt_of_lt_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_of_lt_of_pos lt_mul_of_one_lt_of_lt_of_posₓ'. -/
@@ -1523,7 +1651,7 @@ theorem lt_mul_of_one_lt_of_lt_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b
 
 /- warning: right.one_lt_mul_of_lt_of_le_of_pos -> Right.one_lt_mul_of_lt_of_le_of_pos is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align right.one_lt_mul_of_lt_of_le_of_pos Right.one_lt_mul_of_lt_of_le_of_posₓ'. -/
@@ -1535,7 +1663,7 @@ theorem Right.one_lt_mul_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (
 
 /- warning: right.one_lt_mul_of_le_of_lt_of_nonneg -> Right.one_lt_mul_of_le_of_lt_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align right.one_lt_mul_of_le_of_lt_of_nonneg Right.one_lt_mul_of_le_of_lt_of_nonnegₓ'. -/
@@ -1547,7 +1675,7 @@ theorem Right.one_lt_mul_of_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h
 
 /- warning: right.one_lt_mul_of_lt_of_lt -> Right.one_lt_mul_of_lt_of_lt is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align right.one_lt_mul_of_lt_of_lt Right.one_lt_mul_of_lt_of_ltₓ'. -/
@@ -1559,7 +1687,7 @@ theorem Right.one_lt_mul_of_lt_of_lt [MulPosStrictMono α] (ha : 1 < a) (hb : 1
 
 /- warning: lt_mul_of_one_lt_of_lt_of_nonneg -> lt_mul_of_one_lt_of_lt_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align lt_mul_of_one_lt_of_lt_of_nonneg lt_mul_of_one_lt_of_lt_of_nonnegₓ'. -/
@@ -1570,7 +1698,7 @@ theorem lt_mul_of_one_lt_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b <
 
 /- warning: lt_of_mul_lt_of_one_le_of_nonneg_left -> lt_of_mul_lt_of_one_le_of_nonneg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a c)
 Case conversion may be inaccurate. Consider using '#align lt_of_mul_lt_of_one_le_of_nonneg_left lt_of_mul_lt_of_one_le_of_nonneg_leftₓ'. -/
@@ -1581,7 +1709,7 @@ theorem lt_of_mul_lt_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b < c) (h
 
 /- warning: lt_of_lt_mul_of_le_one_of_nonneg_left -> lt_of_lt_mul_of_le_one_of_nonneg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a b)
 Case conversion may be inaccurate. Consider using '#align lt_of_lt_mul_of_le_one_of_nonneg_left lt_of_lt_mul_of_le_one_of_nonneg_leftₓ'. -/
@@ -1592,7 +1720,7 @@ theorem lt_of_lt_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a < b * c) (h
 
 /- warning: lt_of_lt_mul_of_le_one_of_nonneg_right -> lt_of_lt_mul_of_le_one_of_nonneg_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_3) a c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_3) a c)
 Case conversion may be inaccurate. Consider using '#align lt_of_lt_mul_of_le_one_of_nonneg_right lt_of_lt_mul_of_le_one_of_nonneg_rightₓ'. -/
@@ -1603,7 +1731,7 @@ theorem lt_of_lt_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a < b * c) (
 
 /- warning: le_mul_of_one_le_of_le_of_nonneg -> le_mul_of_one_le_of_le_of_nonneg is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a c))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a c))
 Case conversion may be inaccurate. Consider using '#align le_mul_of_one_le_of_le_of_nonneg le_mul_of_one_le_of_le_of_nonnegₓ'. -/
@@ -1614,7 +1742,7 @@ theorem le_mul_of_one_le_of_le_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (bc : b
 
 /- warning: right.one_le_mul_of_le_of_le -> Right.one_le_mul_of_le_of_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
+  forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b))
 Case conversion may be inaccurate. Consider using '#align right.one_le_mul_of_le_of_le Right.one_le_mul_of_le_of_leₓ'. -/
@@ -1626,7 +1754,7 @@ theorem Right.one_le_mul_of_le_of_le [MulPosMono α] (ha : 1 ≤ a) (hb : 1 ≤
 
 /- warning: le_of_mul_le_of_one_le_of_nonneg_left -> le_of_mul_le_of_one_le_of_nonneg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a c)
 Case conversion may be inaccurate. Consider using '#align le_of_mul_le_of_one_le_of_nonneg_left le_of_mul_le_of_one_le_of_nonneg_leftₓ'. -/
@@ -1637,7 +1765,7 @@ theorem le_of_mul_le_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c)
 
 /- warning: le_of_le_mul_of_le_one_of_nonneg_left -> le_of_le_mul_of_le_one_of_nonneg_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a b)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a b)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : PosMulMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) c (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a b)
 Case conversion may be inaccurate. Consider using '#align le_of_le_mul_of_le_one_of_nonneg_left le_of_le_mul_of_le_one_of_nonneg_leftₓ'. -/
@@ -1648,7 +1776,7 @@ theorem le_of_le_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a ≤ b * c)
 
 /- warning: le_of_mul_le_of_one_le_nonneg_right -> le_of_mul_le_of_one_le_nonneg_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) a b) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b c)
 Case conversion may be inaccurate. Consider using '#align le_of_mul_le_of_one_le_nonneg_right le_of_mul_le_of_one_le_nonneg_rightₓ'. -/
@@ -1659,7 +1787,7 @@ theorem le_of_mul_le_of_one_le_nonneg_right [MulPosMono α] (h : a * b ≤ c) (h
 
 /- warning: le_of_le_mul_of_le_one_of_nonneg_right -> le_of_le_mul_of_le_one_of_nonneg_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a c)
+  forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_1))))) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) c) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_3) a c)
 but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} {c : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : Preorder.{u1} α] [_inst_4 : MulPosMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 _inst_3], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b c)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) b (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) c) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_3) a c)
 Case conversion may be inaccurate. Consider using '#align le_of_le_mul_of_le_one_of_nonneg_right le_of_le_mul_of_le_one_of_nonneg_rightₓ'. -/
@@ -1676,7 +1804,7 @@ variable [LinearOrder α]
 
 /- warning: exists_square_le' -> exists_square_le' is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {a : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : LinearOrder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Exists.{succ u1} α (fun (b : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b b) a))
+  forall {α : Type.{u1}} {a : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : LinearOrder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1) _inst_2 (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 0 (OfNat.mk.{u1} α 0 (Zero.zero.{u1} α _inst_2))) a) -> (Exists.{succ u1} α (fun (b : α) => LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_1)) b b) a))
 but is expected to have type
   forall {α : Type.{u1}} {a : α} [_inst_1 : MulOneClass.{u1} α] [_inst_2 : Zero.{u1} α] [_inst_3 : LinearOrder.{u1} α] [_inst_4 : PosMulStrictMono.{u1} α (MulOneClass.toMul.{u1} α _inst_1) _inst_2 (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α _inst_2)) a) -> (Exists.{succ u1} α (fun (b : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_3))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_1)) b b) a))
 Case conversion may be inaccurate. Consider using '#align exists_square_le' exists_square_le'ₓ'. -/

44e29dbc

bump to nightly-2023-04-21-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/246f6f7989ff86bd07e1b014846f11304f33cf9e

38c06b34

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa, Yuyang Zhao
 
 ! This file was ported from Lean 3 source module algebra.order.ring.lemmas
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit 44e29dbcff83ba7114a464d592b8c3743987c1e5
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1048,7 +1048,10 @@ theorem mul_lt_iff_lt_one_left [MulPosStrictMono α] [MulPosReflectLT α] (b0 :
   Iff.trans (by rw [one_mul]) (mul_lt_mul_right b0)
 #align mul_lt_iff_lt_one_left mul_lt_iff_lt_one_left
 
-/-! Lemmas of the form `1 ≤ b → a ≤ a * b`. -/
+/-! Lemmas of the form `1 ≤ b → a ≤ a * b`.
+
+Variants with `< 0` and `≤ 0` instead of `0 <` and `0 ≤` appear in `algebra/order/ring/defs` (which
+imports this file) as they need additional results which are not yet available here. -/
 
 
 /- warning: mul_le_of_le_one_left -> mul_le_of_le_one_left is a dubious translation:

448144f7

bump to nightly-2023-03-11-16

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

cd44fb92

Diff

@@ -433,7 +433,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align left.mul_pos Left.mul_posₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.mul_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
-  simpa only [mul_zero] using mul_lt_mul_of_pos_left hb ha
+  simpa only [MulZeroClass.mul_zero] using mul_lt_mul_of_pos_left hb ha
 #align left.mul_pos Left.mul_pos
 
 /- warning: mul_pos -> mul_pos is a dubious translation:
@@ -452,7 +452,7 @@ but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_neg_of_pos_of_neg mul_neg_of_pos_of_negₓ'. -/
 theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) : a * b < 0 := by
-  simpa only [mul_zero] using mul_lt_mul_of_pos_left hb ha
+  simpa only [MulZeroClass.mul_zero] using mul_lt_mul_of_pos_left hb ha
 #align mul_neg_of_pos_of_neg mul_neg_of_pos_of_neg
 
 /- warning: zero_lt_mul_left -> zero_lt_mul_left is a dubious translation:
@@ -476,7 +476,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align right.mul_pos Right.mul_posₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.mul_pos [MulPosStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
-  simpa only [zero_mul] using mul_lt_mul_of_pos_right ha hb
+  simpa only [MulZeroClass.zero_mul] using mul_lt_mul_of_pos_right ha hb
 #align right.mul_pos Right.mul_pos
 
 /- warning: mul_neg_of_neg_of_pos -> mul_neg_of_neg_of_pos is a dubious translation:
@@ -486,7 +486,7 @@ but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosStrictMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_neg_of_neg_of_pos mul_neg_of_neg_of_posₓ'. -/
 theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) : a * b < 0 := by
-  simpa only [zero_mul] using mul_lt_mul_of_pos_right ha hb
+  simpa only [MulZeroClass.zero_mul] using mul_lt_mul_of_pos_right ha hb
 #align mul_neg_of_neg_of_pos mul_neg_of_neg_of_pos
 
 /- warning: zero_lt_mul_right -> zero_lt_mul_right is a dubious translation:
@@ -510,7 +510,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align left.mul_nonneg Left.mul_nonnegₓ'. -/
 /-- Assumes left covariance. -/
 theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
-  simpa only [mul_zero] using mul_le_mul_of_nonneg_left hb ha
+  simpa only [MulZeroClass.mul_zero] using mul_le_mul_of_nonneg_left hb ha
 #align left.mul_nonneg Left.mul_nonneg
 
 /- warning: mul_nonneg -> mul_nonneg is a dubious translation:
@@ -529,7 +529,7 @@ but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) b (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_nonpos_of_nonneg_of_nonpos mul_nonpos_of_nonneg_of_nonposₓ'. -/
 theorem mul_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0 := by
-  simpa only [mul_zero] using mul_le_mul_of_nonneg_left hb ha
+  simpa only [MulZeroClass.mul_zero] using mul_le_mul_of_nonneg_left hb ha
 #align mul_nonpos_of_nonneg_of_nonpos mul_nonpos_of_nonneg_of_nonpos
 
 /- warning: right.mul_nonneg -> Right.mul_nonneg is a dubious translation:
@@ -540,7 +540,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align right.mul_nonneg Right.mul_nonnegₓ'. -/
 /-- Assumes right covariance. -/
 theorem Right.mul_nonneg [MulPosMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
-  simpa only [zero_mul] using mul_le_mul_of_nonneg_right ha hb
+  simpa only [MulZeroClass.zero_mul] using mul_le_mul_of_nonneg_right ha hb
 #align right.mul_nonneg Right.mul_nonneg
 
 /- warning: mul_nonpos_of_nonpos_of_nonneg -> mul_nonpos_of_nonpos_of_nonneg is a dubious translation:
@@ -550,7 +550,7 @@ but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosMono.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) a (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1)))) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))))
 Case conversion may be inaccurate. Consider using '#align mul_nonpos_of_nonpos_of_nonneg mul_nonpos_of_nonpos_of_nonnegₓ'. -/
 theorem mul_nonpos_of_nonpos_of_nonneg [MulPosMono α] (ha : a ≤ 0) (hb : 0 ≤ b) : a * b ≤ 0 := by
-  simpa only [zero_mul] using mul_le_mul_of_nonneg_right ha hb
+  simpa only [MulZeroClass.zero_mul] using mul_le_mul_of_nonneg_right ha hb
 #align mul_nonpos_of_nonpos_of_nonneg mul_nonpos_of_nonpos_of_nonneg
 
 /- warning: pos_of_mul_pos_right -> pos_of_mul_pos_right is a dubious translation:
@@ -560,7 +560,7 @@ but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : PosMulReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b)
 Case conversion may be inaccurate. Consider using '#align pos_of_mul_pos_right pos_of_mul_pos_rightₓ'. -/
 theorem pos_of_mul_pos_right [PosMulReflectLT α] (h : 0 < a * b) (ha : 0 ≤ a) : 0 < b :=
-  lt_of_mul_lt_mul_left ((mul_zero a).symm ▸ h : a * 0 < a * b) ha
+  lt_of_mul_lt_mul_left ((MulZeroClass.mul_zero a).symm ▸ h : a * 0 < a * b) ha
 #align pos_of_mul_pos_right pos_of_mul_pos_right
 
 /- warning: pos_of_mul_pos_left -> pos_of_mul_pos_left is a dubious translation:
@@ -570,7 +570,7 @@ but is expected to have type
   forall {α : Type.{u1}} {a : α} {b : α} [_inst_1 : MulZeroClass.{u1} α] [_inst_2 : Preorder.{u1} α] [_inst_3 : MulPosReflectLT.{u1} α (MulZeroClass.toMul.{u1} α _inst_1) (MulZeroClass.toZero.{u1} α _inst_1) _inst_2], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulZeroClass.toMul.{u1} α _inst_1)) a b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_2) (OfNat.ofNat.{u1} α 0 (Zero.toOfNat0.{u1} α (MulZeroClass.toZero.{u1} α _inst_1))) a)
 Case conversion may be inaccurate. Consider using '#align pos_of_mul_pos_left pos_of_mul_pos_leftₓ'. -/
 theorem pos_of_mul_pos_left [MulPosReflectLT α] (h : 0 < a * b) (hb : 0 ≤ b) : 0 < a :=
-  lt_of_mul_lt_mul_right ((zero_mul b).symm ▸ h : 0 * b < a * b) hb
+  lt_of_mul_lt_mul_right ((MulZeroClass.zero_mul b).symm ▸ h : 0 * b < a * b) hb
 #align pos_of_mul_pos_left pos_of_mul_pos_left
 
 /- warning: pos_iff_pos_of_mul_pos -> pos_iff_pos_of_mul_pos is a dubious translation:
@@ -678,7 +678,7 @@ theorem posMulMono_iff_covariant_pos :
   ⟨@PosMulMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_gt
-      · simp only [ha, zero_mul]
+      · simp only [ha, MulZeroClass.zero_mul]
       · exact @CovariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align pos_mul_mono_iff_covariant_pos posMulMono_iff_covariant_pos
 
@@ -693,7 +693,7 @@ theorem mulPosMono_iff_covariant_pos :
   ⟨@MulPosMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_gt
-      · simp only [ha, mul_zero]
+      · simp only [ha, MulZeroClass.mul_zero]
       · exact @CovariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, ha⟩ _ _ h⟩⟩
 #align mul_pos_mono_iff_covariant_pos mulPosMono_iff_covariant_pos
 
@@ -860,7 +860,7 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
   rcases lt_trichotomy 0 a with (ha | rfl | ha)
   · refine' Or.inl ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonneg_of_nonpos ha.le hb
-  · rw [zero_mul] at hab
+  · rw [MulZeroClass.zero_mul] at hab
     exact hab.false.elim
   · refine' Or.inr ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonpos_of_nonneg ha.le hb

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

44e29dbc

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

@@ -5,6 +5,7 @@ Authors: Damiano Testa, Yuyang Zhao
 -/
 import Mathlib.Algebra.CovariantAndContravariant
 import Mathlib.Algebra.GroupWithZero.Defs
+import Mathlib.Tactic.GCongr.Core
 
 #align_import algebra.order.ring.lemmas from "leanprover-community/mathlib"@"44e29dbcff83ba7114a464d592b8c3743987c1e5"
 
@@ -200,18 +201,22 @@ instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
   ⟨fun a _ _ bc => @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_lt
 
+@[gcongr]
 theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c :=
   @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_left mul_le_mul_of_nonneg_left
 
+@[gcongr]
 theorem mul_le_mul_of_nonneg_right [MulPosMono α] (h : b ≤ c) (a0 : 0 ≤ a) : b * a ≤ c * a :=
   @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
 #align mul_le_mul_of_nonneg_right mul_le_mul_of_nonneg_right
 
+@[gcongr]
 theorem mul_lt_mul_of_pos_left [PosMulStrictMono α] (bc : b < c) (a0 : 0 < a) : a * b < a * c :=
   @CovariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_left mul_lt_mul_of_pos_left
 
+@[gcongr]
 theorem mul_lt_mul_of_pos_right [MulPosStrictMono α] (bc : b < c) (a0 : 0 < a) : b * a < c * a :=
   @CovariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ bc
 #align mul_lt_mul_of_pos_right mul_lt_mul_of_pos_right
@@ -463,6 +468,7 @@ theorem mul_le_mul_of_le_of_le [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b)
   (mul_le_mul_of_nonneg_left h₂ a0).trans <| mul_le_mul_of_nonneg_right h₁ d0
 #align mul_le_mul_of_le_of_le mul_le_mul_of_le_of_le
 
+@[gcongr]
 theorem mul_le_mul [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (c0 : 0 ≤ c)
     (b0 : 0 ≤ b) : a * c ≤ b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans <| mul_le_mul_of_nonneg_left h₂ b0

44e29dbc

feat: 0 ≤ a * b ↔ (0 < a → 0 ≤ b) ∧ (0 < b → 0 ≤ a) (#9219)

I had a slightly logic-heavy argument that was nicely simplified by stating this lemma. Also fix a few lemma names.

From LeanAPAP and LeanCamCombi

23429eb2

Diff

@@ -266,6 +266,11 @@ theorem mul_le_mul_right [MulPosMono α] [MulPosReflectLE α] (a0 : 0 < a) : b *
   @rel_iff_cov α>0 α (fun x y => y * x) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_right mul_le_mul_right
 
+alias mul_le_mul_iff_of_pos_left := mul_le_mul_left
+alias mul_le_mul_iff_of_pos_right := mul_le_mul_right
+alias mul_lt_mul_iff_of_pos_left := mul_lt_mul_left
+alias mul_lt_mul_iff_of_pos_right := mul_lt_mul_right
+
 theorem mul_lt_mul_of_pos_of_nonneg [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 ≤ d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans_le (mul_le_mul_of_nonneg_right h₁ d0)
@@ -401,11 +406,9 @@ theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) :
 #align mul_neg_of_pos_of_neg mul_neg_of_pos_of_neg
 
 @[simp]
-theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) :
-    0 < c * b ↔ 0 < b := by
-  rw [← mul_zero c, mul_lt_mul_left h]
-  simp
-#align zero_lt_mul_left zero_lt_mul_left
+theorem mul_pos_iff_of_pos_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < a) :
+    0 < a * b ↔ 0 < b := by simpa using mul_lt_mul_left (b := 0) h
+#align zero_lt_mul_left mul_pos_iff_of_pos_left
 
 /-- Assumes right covariance. -/
 theorem Right.mul_pos [MulPosStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
@@ -417,11 +420,9 @@ theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) :
 #align mul_neg_of_neg_of_pos mul_neg_of_neg_of_pos
 
 @[simp]
-theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
-    0 < b * c ↔ 0 < b := by
-  rw [← zero_mul c, mul_lt_mul_right h]
-  simp
-#align zero_lt_mul_right zero_lt_mul_right
+theorem mul_pos_iff_of_pos_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < b) :
+    0 < a * b ↔ 0 < a := by simpa using mul_lt_mul_right (b := 0) h
+#align zero_lt_mul_right mul_pos_iff_of_pos_right
 
 /-- Assumes left covariance. -/
 theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by

44e29dbc

chore: Rename ...MonoRev to ...ReflectLE in classes (#8890)

Either ReflectLT should be called StrictMonoRev or ReflectLE should be called MonoRev, but we can't have both and hope people understand the relation between them.

4fe66bbf

Diff

@@ -34,13 +34,13 @@ We use the following four typeclasses to reason about left multiplication (`b 
 * `PosMulMono`: If `a ≥ 0`, then `b₁ ≤ b₂ → a * b₁ ≤ a * b₂`.
 * `PosMulStrictMono`: If `a > 0`, then `b₁ < b₂ → a * b₁ < a * b₂`.
 * `PosMulReflectLT`: If `a ≥ 0`, then `a * b₁ < a * b₂ → b₁ < b₂`.
-* `PosMulMonoRev`: If `a > 0`, then `a * b₁ ≤ a * b₂ → b₁ ≤ b₂`.
+* `PosMulReflectLE`: If `a > 0`, then `a * b₁ ≤ a * b₂ → b₁ ≤ b₂`.
 
 We use the following four typeclasses to reason about right multiplication (`a ↦ a * b`):
 * `MulPosMono`: If `b ≥ 0`, then `a₁ ≤ a₂ → a₁ * b ≤ a₂ * b`.
 * `MulPosStrictMono`: If `b > 0`, then `a₁ < a₂ → a₁ * b < a₂ * b`.
 * `MulPosReflectLT`: If `b ≥ 0`, then `a₁ * b < a₂ * b → a₁ < a₂`.
-* `MulPosMonoRev`: If `b > 0`, then `a₁ * b ≤ a₂ * b → a₁ ≤ a₂`.
+* `MulPosReflectLE`: If `b > 0`, then `a₁ * b ≤ a₂ * b → a₁ ≤ a₂`.
 
 ## Implications
 
@@ -49,15 +49,15 @@ implications are:
 *  When `α` is a partial order:
   * `PosMulStrictMono → PosMulMono`
   * `MulPosStrictMono → MulPosMono`
-  * `PosMulMonoRev → PosMulReflectLT`
-  * `MulPosMonoRev → MulPosReflectLT`
+  * `PosMulReflectLE → PosMulReflectLT`
+  * `MulPosReflectLE → MulPosReflectLT`
 * When `α` is a linear order:
-  * `PosMulStrictMono → PosMulMonoRev`
-  * `MulPosStrictMono → MulPosMonoRev` .
+  * `PosMulStrictMono → PosMulReflectLE`
+  * `MulPosStrictMono → MulPosReflectLE` .
 * When the multiplication of `α` is commutative:
   * `PosMulMono → MulPosMono`
   * `PosMulStrictMono → MulPosStrictMono`
-  * `PosMulMonoRev → MulPosMonoRev`
+  * `PosMulReflectLE → MulPosReflectLE`
   * `PosMulReflectLT → MulPosReflectLT`
 
 Further, the bundled non-granular typeclasses imply the granular ones like so:
@@ -155,18 +155,18 @@ namely `a * b₁ ≤ a * b₂ → b₁ ≤ b₂` if `0 < a`.
 
 You should usually not use this very granular typeclass directly, but rather a typeclass like
 `LinearOrderedSemiring`. -/
-abbrev PosMulMonoRev : Prop :=
+abbrev PosMulReflectLE : Prop :=
   ContravariantClass α>0 α (fun x y => x * y) (· ≤ ·)
-#align pos_mul_mono_rev PosMulMonoRev
+#align pos_mul_mono_rev PosMulReflectLE
 
 /-- Typeclass for reverse monotonicity of multiplication by positive elements on the right,
 namely `a₁ * b ≤ a₂ * b → a₁ ≤ a₂` if `0 < b`.
 
 You should usually not use this very granular typeclass directly, but rather a typeclass like
 `LinearOrderedSemiring`. -/
-abbrev MulPosMonoRev : Prop :=
+abbrev MulPosReflectLE : Prop :=
   ContravariantClass α>0 α (fun x y => y * x) (· ≤ ·)
-#align mul_pos_mono_rev MulPosMonoRev
+#align mul_pos_mono_rev MulPosReflectLE
 
 end Abbreviations
 
@@ -224,11 +224,11 @@ theorem lt_of_mul_lt_mul_right [MulPosReflectLT α] (h : b * a < c * a) (a0 : 0
   @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ h
 #align lt_of_mul_lt_mul_right lt_of_mul_lt_mul_right
 
-theorem le_of_mul_le_mul_left [PosMulMonoRev α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
+theorem le_of_mul_le_mul_left [PosMulReflectLE α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_left le_of_mul_le_mul_left
 
-theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
+theorem le_of_mul_le_mul_right [MulPosReflectLE α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_right le_of_mul_le_mul_right
 
@@ -257,12 +257,12 @@ theorem mul_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a)
 #align mul_lt_mul_right mul_lt_mul_right
 
 @[simp]
-theorem mul_le_mul_left [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
+theorem mul_le_mul_left [PosMulMono α] [PosMulReflectLE α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_left mul_le_mul_left
 
 @[simp]
-theorem mul_le_mul_right [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
+theorem mul_le_mul_right [MulPosMono α] [MulPosReflectLE α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
 #align mul_le_mul_right mul_le_mul_right
 
@@ -323,30 +323,30 @@ section LinearOrder
 variable [LinearOrder α]
 
 -- see Note [lower instance priority]
-instance (priority := 100) PosMulStrictMono.toPosMulMonoRev [PosMulStrictMono α] :
-    PosMulMonoRev α :=
+instance (priority := 100) PosMulStrictMono.toPosMulReflectLE [PosMulStrictMono α] :
+    PosMulReflectLE α :=
   ⟨(covariant_lt_iff_contravariant_le _ _ _).1 CovariantClass.elim⟩
 
 -- see Note [lower instance priority]
-instance (priority := 100) MulPosStrictMono.toMulPosMonoRev [MulPosStrictMono α] :
-    MulPosMonoRev α :=
+instance (priority := 100) MulPosStrictMono.toMulPosReflectLE [MulPosStrictMono α] :
+    MulPosReflectLE α :=
   ⟨(covariant_lt_iff_contravariant_le _ _ _).1 CovariantClass.elim⟩
 
-theorem PosMulMonoRev.toPosMulStrictMono [PosMulMonoRev α] : PosMulStrictMono α :=
+theorem PosMulReflectLE.toPosMulStrictMono [PosMulReflectLE α] : PosMulStrictMono α :=
   ⟨(covariant_lt_iff_contravariant_le _ _ _).2 ContravariantClass.elim⟩
-#align pos_mul_mono_rev.to_pos_mul_strict_mono PosMulMonoRev.toPosMulStrictMono
+#align pos_mul_mono_rev.to_pos_mul_strict_mono PosMulReflectLE.toPosMulStrictMono
 
-theorem MulPosMonoRev.toMulPosStrictMono [MulPosMonoRev α] : MulPosStrictMono α :=
+theorem MulPosReflectLE.toMulPosStrictMono [MulPosReflectLE α] : MulPosStrictMono α :=
   ⟨(covariant_lt_iff_contravariant_le _ _ _).2 ContravariantClass.elim⟩
-#align mul_pos_mono_rev.to_mul_pos_strict_mono MulPosMonoRev.toMulPosStrictMono
+#align mul_pos_mono_rev.to_mul_pos_strict_mono MulPosReflectLE.toMulPosStrictMono
 
-theorem posMulStrictMono_iff_posMulMonoRev : PosMulStrictMono α ↔ PosMulMonoRev α :=
-  ⟨@PosMulStrictMono.toPosMulMonoRev _ _ _ _, @PosMulMonoRev.toPosMulStrictMono _ _ _ _⟩
-#align pos_mul_strict_mono_iff_pos_mul_mono_rev posMulStrictMono_iff_posMulMonoRev
+theorem posMulStrictMono_iff_posMulReflectLE : PosMulStrictMono α ↔ PosMulReflectLE α :=
+  ⟨@PosMulStrictMono.toPosMulReflectLE _ _ _ _, @PosMulReflectLE.toPosMulStrictMono _ _ _ _⟩
+#align pos_mul_strict_mono_iff_pos_mul_mono_rev posMulStrictMono_iff_posMulReflectLE
 
-theorem mulPosStrictMono_iff_mulPosMonoRev : MulPosStrictMono α ↔ MulPosMonoRev α :=
-  ⟨@MulPosStrictMono.toMulPosMonoRev _ _ _ _, @MulPosMonoRev.toMulPosStrictMono _ _ _ _⟩
-#align mul_pos_strict_mono_iff_mul_pos_mono_rev mulPosStrictMono_iff_mulPosMonoRev
+theorem mulPosStrictMono_iff_mulPosReflectLE : MulPosStrictMono α ↔ MulPosReflectLE α :=
+  ⟨@MulPosStrictMono.toMulPosReflectLE _ _ _ _, @MulPosReflectLE.toMulPosStrictMono _ _ _ _⟩
+#align mul_pos_strict_mono_iff_mul_pos_mono_rev mulPosStrictMono_iff_mulPosReflectLE
 
 theorem PosMulReflectLT.toPosMulMono [PosMulReflectLT α] : PosMulMono α :=
   ⟨(covariant_le_iff_contravariant_lt _ _ _).2 ContravariantClass.elim⟩
@@ -549,31 +549,31 @@ instance (priority := 100) MulPosStrictMono.toMulPosMono [MulPosStrictMono α] :
 #align mul_pos_strict_mono.to_mul_pos_mono MulPosStrictMono.toMulPosMono
 
 -- see Note [lower instance priority]
-instance (priority := 100) PosMulMonoRev.toPosMulReflectLT [PosMulMonoRev α] :
+instance (priority := 100) PosMulReflectLE.toPosMulReflectLT [PosMulReflectLE α] :
     PosMulReflectLT α :=
   posMulReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
       (le_of_mul_le_mul_of_pos_left h.le a.2).lt_of_ne <| by
         rintro rfl
         simp at h⟩
-#align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulMonoRev.toPosMulReflectLT
+#align pos_mul_mono_rev.to_pos_mul_reflect_lt PosMulReflectLE.toPosMulReflectLT
 
 -- see Note [lower instance priority]
-instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] :
+instance (priority := 100) MulPosReflectLE.toMulPosReflectLT [MulPosReflectLE α] :
     MulPosReflectLT α :=
   mulPosReflectLT_iff_contravariant_pos.2
     ⟨fun a b c h =>
       (le_of_mul_le_mul_of_pos_right h.le a.2).lt_of_ne <| by
         rintro rfl
         simp at h⟩
-#align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosMonoRev.toMulPosReflectLT
+#align mul_pos_mono_rev.to_mul_pos_reflect_lt MulPosReflectLE.toMulPosReflectLT
 
-theorem mul_left_cancel_iff_of_pos [PosMulMonoRev α] (a0 : 0 < a) : a * b = a * c ↔ b = c :=
+theorem mul_left_cancel_iff_of_pos [PosMulReflectLE α] (a0 : 0 < a) : a * b = a * c ↔ b = c :=
   ⟨fun h => (le_of_mul_le_mul_of_pos_left h.le a0).antisymm <|
     le_of_mul_le_mul_of_pos_left h.ge a0, congr_arg _⟩
 #align mul_left_cancel_iff_of_pos mul_left_cancel_iff_of_pos
 
-theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c * b ↔ a = c :=
+theorem mul_right_cancel_iff_of_pos [MulPosReflectLE α] (b0 : 0 < b) : a * b = c * b ↔ a = c :=
   ⟨fun h => (le_of_mul_le_mul_of_pos_right h.le b0).antisymm <|
     le_of_mul_le_mul_of_pos_right h.ge b0, congr_arg (· * b)⟩
 #align mul_right_cancel_iff_of_pos mul_right_cancel_iff_of_pos
@@ -661,7 +661,7 @@ which assume left covariance. -/
 
 
 @[simp]
-theorem le_mul_iff_one_le_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a ≤ a * b ↔ 1 ≤ b :=
+lemma le_mul_iff_one_le_right [PosMulMono α] [PosMulReflectLE α] (a0 : 0 < a) : a ≤ a * b ↔ 1 ≤ b :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align le_mul_iff_one_le_right le_mul_iff_one_le_right
 
@@ -672,7 +672,7 @@ theorem lt_mul_iff_one_lt_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 :
 #align lt_mul_iff_one_lt_right lt_mul_iff_one_lt_right
 
 @[simp]
-theorem mul_le_iff_le_one_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a ↔ b ≤ 1 :=
+lemma mul_le_iff_le_one_right [PosMulMono α] [PosMulReflectLE α] (a0 : 0 < a) : a * b ≤ a ↔ b ≤ 1 :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
 #align mul_le_iff_le_one_right mul_le_iff_le_one_right
 
@@ -687,7 +687,7 @@ which assume right covariance. -/
 
 
 @[simp]
-theorem le_mul_iff_one_le_left [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : a ≤ b * a ↔ 1 ≤ b :=
+lemma le_mul_iff_one_le_left [MulPosMono α] [MulPosReflectLE α] (a0 : 0 < a) : a ≤ b * a ↔ 1 ≤ b :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right a0)
 #align le_mul_iff_one_le_left le_mul_iff_one_le_left
 
@@ -698,7 +698,7 @@ theorem lt_mul_iff_one_lt_left [MulPosStrictMono α] [MulPosReflectLT α] (a0 :
 #align lt_mul_iff_one_lt_left lt_mul_iff_one_lt_left
 
 @[simp]
-theorem mul_le_iff_le_one_left [MulPosMono α] [MulPosMonoRev α] (b0 : 0 < b) : a * b ≤ b ↔ a ≤ 1 :=
+lemma mul_le_iff_le_one_left [MulPosMono α] [MulPosReflectLE α] (b0 : 0 < b) : a * b ≤ b ↔ a ≤ 1 :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right b0)
 #align mul_le_iff_le_one_left mul_le_iff_le_one_left
 
@@ -1048,24 +1048,24 @@ theorem mulPosMono_iff_mulPosStrictMono : MulPosMono α ↔ MulPosStrictMono α
   ⟨@MulPosMono.toMulPosStrictMono α _ _, @MulPosStrictMono.toMulPosMono α _ _⟩
 #align mul_pos_mono_iff_mul_pos_strict_mono mulPosMono_iff_mulPosStrictMono
 
-theorem PosMulReflectLT.toPosMulMonoRev [PosMulReflectLT α] : PosMulMonoRev α :=
+theorem PosMulReflectLT.toPosMulReflectLE [PosMulReflectLT α] : PosMulReflectLE α :=
   ⟨fun x _ _ h =>
     h.eq_or_lt.elim (le_of_eq ∘ mul_left_cancel₀ x.2.ne.symm) fun h' =>
       (lt_of_mul_lt_mul_left h' x.2.le).le⟩
-#align pos_mul_reflect_lt.to_pos_mul_mono_rev PosMulReflectLT.toPosMulMonoRev
+#align pos_mul_reflect_lt.to_pos_mul_mono_rev PosMulReflectLT.toPosMulReflectLE
 
-theorem posMulMonoRev_iff_posMulReflectLT : PosMulMonoRev α ↔ PosMulReflectLT α :=
-  ⟨@PosMulMonoRev.toPosMulReflectLT α _ _, @PosMulReflectLT.toPosMulMonoRev α _ _⟩
-#align pos_mul_mono_rev_iff_pos_mul_reflect_lt posMulMonoRev_iff_posMulReflectLT
+theorem posMulReflectLE_iff_posMulReflectLT : PosMulReflectLE α ↔ PosMulReflectLT α :=
+  ⟨@PosMulReflectLE.toPosMulReflectLT α _ _, @PosMulReflectLT.toPosMulReflectLE α _ _⟩
+#align pos_mul_mono_rev_iff_pos_mul_reflect_lt posMulReflectLE_iff_posMulReflectLT
 
-theorem MulPosReflectLT.toMulPosMonoRev [MulPosReflectLT α] : MulPosMonoRev α :=
+theorem MulPosReflectLT.toMulPosReflectLE [MulPosReflectLT α] : MulPosReflectLE α :=
   ⟨fun x _ _ h => h.eq_or_lt.elim (le_of_eq ∘ mul_right_cancel₀ x.2.ne.symm) fun h' =>
     (lt_of_mul_lt_mul_right h' x.2.le).le⟩
-#align mul_pos_reflect_lt.to_mul_pos_mono_rev MulPosReflectLT.toMulPosMonoRev
+#align mul_pos_reflect_lt.to_mul_pos_mono_rev MulPosReflectLT.toMulPosReflectLE
 
-theorem mulPosMonoRev_iff_mulPosReflectLT : MulPosMonoRev α ↔ MulPosReflectLT α :=
-  ⟨@MulPosMonoRev.toMulPosReflectLT α _ _, @MulPosReflectLT.toMulPosMonoRev α _ _⟩
-#align mul_pos_mono_rev_iff_mul_pos_reflect_lt mulPosMonoRev_iff_mulPosReflectLT
+theorem mulPosReflectLE_iff_mulPosReflectLT : MulPosReflectLE α ↔ MulPosReflectLT α :=
+  ⟨@MulPosReflectLE.toMulPosReflectLT α _ _, @MulPosReflectLT.toMulPosReflectLE α _ _⟩
+#align mul_pos_mono_rev_iff_mul_pos_reflect_lt mulPosReflectLE_iff_mulPosReflectLT
 
 end PartialOrder
 
@@ -1087,8 +1087,8 @@ theorem posMulMono_iff_mulPosMono : PosMulMono α ↔ MulPosMono α := by
   simp only [PosMulMono, MulPosMono, IsSymmOp.symm_op]
 #align pos_mul_mono_iff_mul_pos_mono posMulMono_iff_mulPosMono
 
-theorem posMulMonoRev_iff_mulPosMonoRev : PosMulMonoRev α ↔ MulPosMonoRev α := by
-  simp only [PosMulMonoRev, MulPosMonoRev, IsSymmOp.symm_op]
-#align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulMonoRev_iff_mulPosMonoRev
+theorem posMulReflectLE_iff_mulPosReflectLE : PosMulReflectLE α ↔ MulPosReflectLE α := by
+  simp only [PosMulReflectLE, MulPosReflectLE, IsSymmOp.symm_op]
+#align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulReflectLE_iff_mulPosReflectLE
 
 end CommSemigroupHasZero

44e29dbc

doc: Better documentation for PosMulMono and friends (#8841)

And also improve the docstrings of the eight typeclasses. I always wished they told me what they state, rather than what nonsense they're the abbreviation of!

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

a27d7b3b

Diff

@@ -9,110 +9,161 @@ import Mathlib.Algebra.GroupWithZero.Defs
 #align_import algebra.order.ring.lemmas from "leanprover-community/mathlib"@"44e29dbcff83ba7114a464d592b8c3743987c1e5"
 
 /-!
-# Multiplication by ·positive· elements is monotonic
-
-Let `α` be a type with `<` and `0`.  We use the type `{x : α // 0 < x}` of positive elements of `α`
-to prove results about monotonicity of multiplication.  We also introduce the local notation `α>0`
-for the subtype `{x : α // 0 < x}`:
-
-If the type `α` also has a multiplication, then we combine this with (`Contravariant`)
-`CovariantClass`es to assume that multiplication by positive elements is (strictly) monotone on a
-`MulZeroClass`, `MonoidWithZero`,...
-More specifically, we use extensively the following typeclasses:
-
-* monotone left
-* * `CovariantClass α>0 α (fun x y ↦ x * y) (≤)`, abbreviated `PosMulMono α`,
-    expressing that multiplication by positive elements on the left is monotone;
-* * `CovariantClass α>0 α (fun x y ↦ x * y) (<)`, abbreviated `PosMulStrictMono α`,
-    expressing that multiplication by positive elements on the left is strictly monotone;
-* monotone right
-* * `CovariantClass α>0 α (fun x y ↦ y * x) (≤)`, abbreviated `MulPosMono α`,
-    expressing that multiplication by positive elements on the right is monotone;
-* * `CovariantClass α>0 α (fun x y ↦ y * x) (<)`, abbreviated `MulPosStrictMono α`,
-    expressing that multiplication by positive elements on the right is strictly monotone.
-* reverse monotone left
-* * `ContravariantClass α>0 α (fun x y ↦ x * y) (≤)`, abbreviated `PosMulMonoRev α`,
-    expressing that multiplication by positive elements on the left is reverse monotone;
-* * `ContravariantClass α>0 α (fun x y ↦ x * y) (<)`, abbreviated `PosMulReflectLT α`,
-    expressing that multiplication by positive elements on the left is strictly reverse monotone;
-* reverse reverse monotone right
-* * `ContravariantClass α>0 α (fun x y ↦ y * x) (≤)`, abbreviated `MulPosMonoRev α`,
-    expressing that multiplication by positive elements on the right is reverse monotone;
-* * `ContravariantClass α>0 α (fun x y ↦ y * x) (<)`, abbreviated `MulPosReflectLT α`,
-    expressing that multiplication by positive elements on the right is strictly reverse monotone.
+# Monotonicity of multiplication by positive elements
+
+This file defines typeclasses to reason about monotonicity of the operations
+* `b ↦ a * b`, "left multiplication"
+* `a ↦ a * b`, "right multiplication"
+
+We use eight typeclasses to encode the various properties we care about for those two operations.
+These typeclasses are meant to be mostly internal to this file, to set up each lemma in the
+appropriate generality.
+
+Less granular typeclasses like `OrderedAddCommMonoid`, `LinearOrderedField`` should be enough for
+most purposes, and the system is set up so that they imply the correct granular typeclasses here.
+If those are enough for you, you may stop reading here! Else, beware that what follows is a bit
+technical.
+
+## Definitions
+
+In all that follows, `α` is an orders which has a `0` and a multiplication. Note however that we do
+not use lawfulness of this action in most of the file. Hence `*` should be considered here as a
+mostly arbitrary function `α → α → α`.
+
+We use the following four typeclasses to reason about left multiplication (`b ↦ a * b`):
+* `PosMulMono`: If `a ≥ 0`, then `b₁ ≤ b₂ → a * b₁ ≤ a * b₂`.
+* `PosMulStrictMono`: If `a > 0`, then `b₁ < b₂ → a * b₁ < a * b₂`.
+* `PosMulReflectLT`: If `a ≥ 0`, then `a * b₁ < a * b₂ → b₁ < b₂`.
+* `PosMulMonoRev`: If `a > 0`, then `a * b₁ ≤ a * b₂ → b₁ ≤ b₂`.
+
+We use the following four typeclasses to reason about right multiplication (`a ↦ a * b`):
+* `MulPosMono`: If `b ≥ 0`, then `a₁ ≤ a₂ → a₁ * b ≤ a₂ * b`.
+* `MulPosStrictMono`: If `b > 0`, then `a₁ < a₂ → a₁ * b < a₂ * b`.
+* `MulPosReflectLT`: If `b ≥ 0`, then `a₁ * b < a₂ * b → a₁ < a₂`.
+* `MulPosMonoRev`: If `b > 0`, then `a₁ * b ≤ a₂ * b → a₁ ≤ a₂`.
+
+## Implications
+
+As `α` gets more and more structure, those typeclasses end up being equivalent. The commonly used
+implications are:
+*  When `α` is a partial order:
+  * `PosMulStrictMono → PosMulMono`
+  * `MulPosStrictMono → MulPosMono`
+  * `PosMulMonoRev → PosMulReflectLT`
+  * `MulPosMonoRev → MulPosReflectLT`
+* When `α` is a linear order:
+  * `PosMulStrictMono → PosMulMonoRev`
+  * `MulPosStrictMono → MulPosMonoRev` .
+* When the multiplication of `α` is commutative:
+  * `PosMulMono → MulPosMono`
+  * `PosMulStrictMono → MulPosStrictMono`
+  * `PosMulMonoRev → MulPosMonoRev`
+  * `PosMulReflectLT → MulPosReflectLT`
+
+Further, the bundled non-granular typeclasses imply the granular ones like so:
+* `OrderedSemiring → PosMulMono`
+* `OrderedSemiring → MulPosMono`
+* `StrictOrderedSemiring → PosMulStrictMono`
+* `StrictOrderedSemiring → MulPosStrictMono`
+
+All these are registered as instances, which means that in practice you should not worry about these
+implications. However, if you encounter a case where you think a statement is true but not covered
+by the current implications, please bring it up on Zulip!
 
 ## Notation
 
 The following is local notation in this file:
 * `α≥0`: `{x : α // 0 ≤ x}`
 * `α>0`: `{x : α // 0 < x}`
+
+See https://leanprover.zulipchat.com/#narrow/stream/113488-general/topic/notation.20for.20positive.20elements
+for a discussion about this notation, and whether to enable it globally (note that the notation is
+currently global but broken, hence actually only works locally).
 -/
 
 
 variable (α : Type*)
 
--- mathport name: «exprα≥0»
-/- Notations for nonnegative and positive elements
-https://
-leanprover.zulipchat.com/#narrow/stream/113488-general/topic/notation.20for.20positive.20elements
--/
-section Abbreviations
-
-variable [Mul α] [Zero α] [Preorder α]
-
 set_option quotPrecheck false in
 /-- Local notation for the nonnegative elements of a type `α`. TODO: actually make local. -/
 notation "α≥0" => { x : α // 0 ≤ x }
 
--- mathport name: «exprα>0»
 set_option quotPrecheck false in
 /-- Local notation for the positive elements of a type `α`. TODO: actually make local. -/
 notation "α>0" => { x : α // 0 < x }
 
-/-- `PosMulMono α` is an abbreviation for `CovariantClass α≥0 α (fun x y ↦ x * y) (≤)`,
-expressing that multiplication by nonnegative elements on the left is monotone. -/
+section Abbreviations
+
+variable [Mul α] [Zero α] [Preorder α]
+
+/-- Typeclass for monotonicity of multiplication by nonnegative elements on the left,
+namely `b₁ ≤ b₂ → a * b₁ ≤ a * b₂` if `0 ≤ a`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`OrderedSemiring`. -/
 abbrev PosMulMono : Prop :=
   CovariantClass α≥0 α (fun x y => x * y) (· ≤ ·)
 #align pos_mul_mono PosMulMono
 
-/-- `MulPosMono α` is an abbreviation for `CovariantClass α≥0 α (fun x y ↦ y * x) (≤)`,
-expressing that multiplication by nonnegative elements on the right is monotone. -/
+/-- Typeclass for monotonicity of multiplication by nonnegative elements on the right,
+namely `a₁ ≤ a₂ → a₁ * b ≤ a₂ * b` if `0 ≤ b`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`OrderedSemiring`. -/
 abbrev MulPosMono : Prop :=
   CovariantClass α≥0 α (fun x y => y * x) (· ≤ ·)
 #align mul_pos_mono MulPosMono
 
-/-- `PosMulStrictMono α` is an abbreviation for `CovariantClass α>0 α (fun x y ↦ x * y) (<)`,
-expressing that multiplication by positive elements on the left is strictly monotone. -/
+/-- Typeclass for strict monotonicity of multiplication by positive elements on the left,
+namely `b₁ < b₂ → a * b₁ < a * b₂` if `0 < a`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`StrictOrderedSemiring`. -/
 abbrev PosMulStrictMono : Prop :=
   CovariantClass α>0 α (fun x y => x * y) (· < ·)
 #align pos_mul_strict_mono PosMulStrictMono
 
-/-- `MulPosStrictMono α` is an abbreviation for `CovariantClass α>0 α (fun x y ↦ y * x) (<)`,
-expressing that multiplication by positive elements on the right is strictly monotone. -/
+/-- Typeclass for strict monotonicity of multiplication by positive elements on the right,
+namely `a₁ < a₂ → a₁ * b < a₂ * b` if `0 < b`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`StrictOrderedSemiring`. -/
 abbrev MulPosStrictMono : Prop :=
   CovariantClass α>0 α (fun x y => y * x) (· < ·)
 #align mul_pos_strict_mono MulPosStrictMono
 
-/-- `PosMulReflectLT α` is an abbreviation for `ContravariantClas α≥0 α (fun x y ↦ x * y) (<)`,
-expressing that multiplication by nonnegative elements on the left is strictly reverse monotone. -/
+/-- Typeclass for strict reverse monotonicity of multiplication by nonnegative elements on
+the left, namely `a * b₁ < a * b₂ → b₁ < b₂` if `0 ≤ a`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`LinearOrderedSemiring`. -/
 abbrev PosMulReflectLT : Prop :=
   ContravariantClass α≥0 α (fun x y => x * y) (· < ·)
 #align pos_mul_reflect_lt PosMulReflectLT
 
-/-- `MulPosReflectLT α` is an abbreviation for `ContravariantClas α≥0 α (fun x y ↦ y * x) (<)`,
-expressing that multiplication by nonnegative elements on the right is strictly reverse monotone. -/
+/-- Typeclass for strict reverse monotonicity of multiplication by nonnegative elements on
+the right, namely `a₁ * b < a₂ * b → a₁ < a₂` if `0 ≤ b`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`LinearOrderedSemiring`. -/
 abbrev MulPosReflectLT : Prop :=
   ContravariantClass α≥0 α (fun x y => y * x) (· < ·)
 #align mul_pos_reflect_lt MulPosReflectLT
 
-/-- `PosMulMonoRev α` is an abbreviation for `ContravariantClas α>0 α (fun x y ↦ x * y) (≤)`,
-expressing that multiplication by positive elements on the left is reverse monotone. -/
+/-- Typeclass for reverse monotonicity of multiplication by positive elements on the left,
+namely `a * b₁ ≤ a * b₂ → b₁ ≤ b₂` if `0 < a`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`LinearOrderedSemiring`. -/
 abbrev PosMulMonoRev : Prop :=
   ContravariantClass α>0 α (fun x y => x * y) (· ≤ ·)
 #align pos_mul_mono_rev PosMulMonoRev
 
-/-- `MulPosMonoRev α` is an abbreviation for `ContravariantClas α>0 α (fun x y ↦ y * x) (≤)`,
-expressing that multiplication by positive elements on the right is reverse monotone. -/
+/-- Typeclass for reverse monotonicity of multiplication by positive elements on the right,
+namely `a₁ * b ≤ a₂ * b → a₁ ≤ a₂` if `0 < b`.
+
+You should usually not use this very granular typeclass directly, but rather a typeclass like
+`LinearOrderedSemiring`. -/
 abbrev MulPosMonoRev : Prop :=
   ContravariantClass α>0 α (fun x y => y * x) (· ≤ ·)
 #align mul_pos_mono_rev MulPosMonoRev

44e29dbc

chore: space after ← (#8178)

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

5fb9beab

Diff

@@ -352,7 +352,7 @@ theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) :
 @[simp]
 theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) :
     0 < c * b ↔ 0 < b := by
-  rw [←mul_zero c, mul_lt_mul_left h]
+  rw [← mul_zero c, mul_lt_mul_left h]
   simp
 #align zero_lt_mul_left zero_lt_mul_left
 
@@ -368,7 +368,7 @@ theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) :
 @[simp]
 theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
     0 < b * c ↔ 0 < b := by
-  rw [←zero_mul c, mul_lt_mul_right h]
+  rw [← zero_mul c, mul_lt_mul_right h]
   simp
 #align zero_lt_mul_right zero_lt_mul_right
 
@@ -452,7 +452,7 @@ theorem posMulMono_iff_covariant_pos :
   ⟨@PosMulMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
-      · simp [←ha]
+      · simp [← ha]
       · exact @CovariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, ha⟩ _ _ h ⟩⟩
 #align pos_mul_mono_iff_covariant_pos posMulMono_iff_covariant_pos
 
@@ -461,7 +461,7 @@ theorem mulPosMono_iff_covariant_pos :
   ⟨@MulPosMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
-      · simp [←ha]
+      · simp [← ha]
       · exact @CovariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, ha⟩ _ _ h ⟩⟩
 #align mul_pos_mono_iff_covariant_pos mulPosMono_iff_covariant_pos
 
@@ -470,7 +470,7 @@ theorem posMulReflectLT_iff_contravariant_pos :
   ⟨@PosMulReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
-      · simp [←ha] at h
+      · simp [← ha] at h
       · exact @ContravariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨_, ha⟩ _ _ h ⟩⟩
 #align pos_mul_reflect_lt_iff_contravariant_pos posMulReflectLT_iff_contravariant_pos
 
@@ -479,7 +479,7 @@ theorem mulPosReflectLT_iff_contravariant_pos :
   ⟨@MulPosReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
-      · simp [←ha] at h
+      · simp [← ha] at h
       · exact @ContravariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨_, ha⟩ _ _ h ⟩⟩
 #align mul_pos_reflect_lt_iff_contravariant_pos mulPosReflectLT_iff_contravariant_pos

44e29dbc

chore(Co(ntra)variantClass): generalize and remove duplicates (#6677)

4 files have major changes:

Algebra/CovariantAndContravariant.lean

Add new theorem contravariant_le_iff_contravariant_lt_and_eq.
Add covariantClass_le_of_lt generalizing and replacing Mul.to_covariantClass_left/right in Algebra/Order/Monoid/Defs.lean
Replace CommSemigroup by IsSymmOp N N mu and replace CancelSemigroup by IsMulCancel, removing superfluous associativity assumption.
new theorems covariant_lt_of_covariant_le_of_contravariant_eq and contravariant_le_of_contravariant_eq_and_lt that could replace eight instances when appropriate refactoring is in place.
Golfs
Fix changed names in other files.

Algebra/Order/Monoid/Lemmas.lean

Generalize mul_eq_mul_iff_eq_and_eq and remove the less general Left/Right.mul_eq_mul_iff_eq_and_eq.
Move mul_le_mul_iff_of_ge.
Introduce the more general Left/Right versions of min_le_max_of_mul_le_mul.
Move min_lt_max_of_mul_lt_mul here from Algebra/GroupPower/Order.lean.
Replace CommSemigroup by IsSymmOp.

Algebra/Order/Monoid/Basic.lean

Remove eq_and_eq_of_le_of_le_of_mul_le as it's just one direction of mul_le_mul_iff_of_ge but with more assumptions.

Algebra/Order/Ring/Lemmas.lean

Generalize two versions of mul_eq_mul_iff_eq_and_eq_of_pos
Golfs

Changes to Algebra/Group/UniqueProds.lean and Algebra/MonoidAlgebra/NoZeroDivisors.lean are in declarations that will be removed by #6723.

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

9476eae9

Diff

@@ -274,19 +274,19 @@ variable [LinearOrder α]
 -- see Note [lower instance priority]
 instance (priority := 100) PosMulStrictMono.toPosMulMonoRev [PosMulStrictMono α] :
     PosMulMonoRev α :=
-  ⟨fun x _ _ h => le_of_not_lt fun h' => h.not_lt <| mul_lt_mul_of_pos_left h' x.prop⟩
+  ⟨(covariant_lt_iff_contravariant_le _ _ _).1 CovariantClass.elim⟩
 
 -- see Note [lower instance priority]
 instance (priority := 100) MulPosStrictMono.toMulPosMonoRev [MulPosStrictMono α] :
     MulPosMonoRev α :=
-  ⟨fun x _ _ h => le_of_not_lt fun h' => h.not_lt <| mul_lt_mul_of_pos_right h' x.prop⟩
+  ⟨(covariant_lt_iff_contravariant_le _ _ _).1 CovariantClass.elim⟩
 
 theorem PosMulMonoRev.toPosMulStrictMono [PosMulMonoRev α] : PosMulStrictMono α :=
-  ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| le_of_mul_le_mul_of_pos_left h' x.prop⟩
+  ⟨(covariant_lt_iff_contravariant_le _ _ _).2 ContravariantClass.elim⟩
 #align pos_mul_mono_rev.to_pos_mul_strict_mono PosMulMonoRev.toPosMulStrictMono
 
 theorem MulPosMonoRev.toMulPosStrictMono [MulPosMonoRev α] : MulPosStrictMono α :=
-  ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| le_of_mul_le_mul_of_pos_right h' x.prop⟩
+  ⟨(covariant_lt_iff_contravariant_le _ _ _).2 ContravariantClass.elim⟩
 #align mul_pos_mono_rev.to_mul_pos_strict_mono MulPosMonoRev.toMulPosStrictMono
 
 theorem posMulStrictMono_iff_posMulMonoRev : PosMulStrictMono α ↔ PosMulMonoRev α :=
@@ -298,21 +298,25 @@ theorem mulPosStrictMono_iff_mulPosMonoRev : MulPosStrictMono α ↔ MulPosMonoR
 #align mul_pos_strict_mono_iff_mul_pos_mono_rev mulPosStrictMono_iff_mulPosMonoRev
 
 theorem PosMulReflectLT.toPosMulMono [PosMulReflectLT α] : PosMulMono α :=
-  ⟨fun x _ _ h => le_of_not_lt fun h' => h.not_lt <| lt_of_mul_lt_mul_left h' x.prop⟩
+  ⟨(covariant_le_iff_contravariant_lt _ _ _).2 ContravariantClass.elim⟩
 #align pos_mul_reflect_lt.to_pos_mul_mono PosMulReflectLT.toPosMulMono
 
 theorem MulPosReflectLT.toMulPosMono [MulPosReflectLT α] : MulPosMono α :=
-  ⟨fun x _ _ h => le_of_not_lt fun h' => h.not_lt <| lt_of_mul_lt_mul_right h' x.prop⟩
+  ⟨(covariant_le_iff_contravariant_lt _ _ _).2 ContravariantClass.elim⟩
 #align mul_pos_reflect_lt.to_mul_pos_mono MulPosReflectLT.toMulPosMono
 
 theorem PosMulMono.toPosMulReflectLT [PosMulMono α] : PosMulReflectLT α :=
-  ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| mul_le_mul_of_nonneg_left h' x.prop⟩
+  ⟨(covariant_le_iff_contravariant_lt _ _ _).1 CovariantClass.elim⟩
 #align pos_mul_mono.to_pos_mul_reflect_lt PosMulMono.toPosMulReflectLT
 
 theorem MulPosMono.toMulPosReflectLT [MulPosMono α] : MulPosReflectLT α :=
-  ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| mul_le_mul_of_nonneg_right h' x.prop⟩
+  ⟨(covariant_le_iff_contravariant_lt _ _ _).1 CovariantClass.elim⟩
 #align mul_pos_mono.to_mul_pos_reflect_lt MulPosMono.toMulPosReflectLT
 
+/- TODO: Currently, only one in four of the above are made instances; we could consider making
+  both directions of `covariant_le_iff_contravariant_lt` and `covariant_lt_iff_contravariant_le`
+  instances, then all of the above become redundant instances, but there are performance issues. -/
+
 theorem posMulMono_iff_posMulReflectLT : PosMulMono α ↔ PosMulReflectLT α :=
   ⟨@PosMulMono.toPosMulReflectLT _ _ _ _, @PosMulReflectLT.toPosMulMono _ _ _ _⟩
 #align pos_mul_mono_iff_pos_mul_reflect_lt posMulMono_iff_posMulReflectLT
@@ -483,16 +487,14 @@ theorem mulPosReflectLT_iff_contravariant_pos :
 -- but implicit argument handling causes that to break
 -- see Note [lower instance priority]
 instance (priority := 100) PosMulStrictMono.toPosMulMono [PosMulStrictMono α] : PosMulMono α :=
-  posMulMono_iff_covariant_pos.2 <|
-    ⟨fun a _ _ h => StrictMono.monotone (λ _ _ h' => mul_lt_mul_of_pos_left h' a.prop) h⟩
+  posMulMono_iff_covariant_pos.2 (covariantClass_le_of_lt _ _ _)
 #align pos_mul_strict_mono.to_pos_mul_mono PosMulStrictMono.toPosMulMono
 
 -- Porting note: mathlib3 proofs would look like `StrictMono.monotone <| @CovariantClass.elim ..`
 -- but implicit argument handling causes that to break
 -- see Note [lower instance priority]
 instance (priority := 100) MulPosStrictMono.toMulPosMono [MulPosStrictMono α] : MulPosMono α :=
-  mulPosMono_iff_covariant_pos.2 <|
-    ⟨fun a _ _ h => StrictMono.monotone (λ _ _ h' => mul_lt_mul_of_pos_right h' a.prop) h⟩
+  mulPosMono_iff_covariant_pos.2 (covariantClass_le_of_lt _ _ _)
 #align mul_pos_strict_mono.to_mul_pos_mono MulPosStrictMono.toMulPosMono
 
 -- see Note [lower instance priority]
@@ -525,26 +527,24 @@ theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c
     le_of_mul_le_mul_of_pos_right h.ge b0, congr_arg (· * b)⟩
 #align mul_right_cancel_iff_of_pos mul_right_cancel_iff_of_pos
 
-theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
-    [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (a0 : 0 < a) (d0 : 0 < d) :
+theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono α]
+    (hab : a ≤ b) (hcd : c ≤ d) (a0 : 0 < a) (d0 : 0 < d) :
     a * c = b * d ↔ a = b ∧ c = d := by
-  refine' ⟨fun h => _, fun h => congr_arg₂ (· * ·) h.1 h.2⟩
-  rcases hac.eq_or_lt with (rfl | hac)
-  · exact ⟨rfl, (mul_left_cancel_iff_of_pos a0).mp h⟩
-  rcases eq_or_lt_of_le hbd with (rfl | hbd)
-  · exact ⟨(mul_right_cancel_iff_of_pos d0).mp h, rfl⟩
-  exact ((mul_lt_mul_of_pos_of_pos hac hbd a0 d0).ne h).elim
+  refine' ⟨fun h ↦ _, by rintro ⟨rfl, rfl⟩; rfl⟩
+  simp only [eq_iff_le_not_lt, hab, hcd, true_and]
+  refine' ⟨fun hab ↦ h.not_lt _, fun hcd ↦ h.not_lt _⟩
+  · exact (mul_le_mul_of_nonneg_left hcd a0.le).trans_lt (mul_lt_mul_of_pos_right hab d0)
+  · exact (mul_lt_mul_of_pos_left hcd a0).trans_le (mul_le_mul_of_nonneg_right hab d0.le)
 #align mul_eq_mul_iff_eq_and_eq_of_pos mul_eq_mul_iff_eq_and_eq_of_pos
 
-theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
-    [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (b0 : 0 < b) (c0 : 0 < c) :
+theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono α]
+    (hab : a ≤ b) (hcd : c ≤ d) (b0 : 0 < b) (c0 : 0 < c) :
     a * c = b * d ↔ a = b ∧ c = d := by
-  refine' ⟨fun h => _, fun h => congr_arg₂ (· * ·) h.1 h.2⟩
-  rcases hac.eq_or_lt with (rfl | hac)
-  · exact ⟨rfl, (mul_left_cancel_iff_of_pos b0).mp h⟩
-  rcases eq_or_lt_of_le hbd with (rfl | hbd)
-  · exact ⟨(mul_right_cancel_iff_of_pos c0).mp h, rfl⟩
-  exact ((mul_lt_mul_of_lt_of_lt' hac hbd b0 c0).ne h).elim
+  refine' ⟨fun h ↦ _, by rintro ⟨rfl, rfl⟩; rfl⟩
+  simp only [eq_iff_le_not_lt, hab, hcd, true_and]
+  refine' ⟨fun hab ↦ h.not_lt _, fun hcd ↦ h.not_lt _⟩
+  · exact (mul_lt_mul_of_pos_right hab c0).trans_le (mul_le_mul_of_nonneg_left hcd b0.le)
+  · exact (mul_le_mul_of_nonneg_right hab c0.le).trans_lt (mul_lt_mul_of_pos_left hcd b0)
 #align mul_eq_mul_iff_eq_and_eq_of_pos' mul_eq_mul_iff_eq_and_eq_of_pos'
 
 end PartialOrder
@@ -1022,22 +1022,22 @@ end CancelMonoidWithZero
 
 section CommSemigroupHasZero
 
-variable [CommSemigroup α] [Zero α] [Preorder α]
+variable [Mul α] [IsSymmOp α α (· * ·)] [Zero α] [Preorder α]
 
 theorem posMulStrictMono_iff_mulPosStrictMono : PosMulStrictMono α ↔ MulPosStrictMono α := by
-  simp only [PosMulStrictMono, MulPosStrictMono, mul_comm]
+  simp only [PosMulStrictMono, MulPosStrictMono, IsSymmOp.symm_op]
 #align pos_mul_strict_mono_iff_mul_pos_strict_mono posMulStrictMono_iff_mulPosStrictMono
 
 theorem posMulReflectLT_iff_mulPosReflectLT : PosMulReflectLT α ↔ MulPosReflectLT α := by
-  simp only [PosMulReflectLT, MulPosReflectLT, mul_comm]
+  simp only [PosMulReflectLT, MulPosReflectLT, IsSymmOp.symm_op]
 #align pos_mul_reflect_lt_iff_mul_pos_reflect_lt posMulReflectLT_iff_mulPosReflectLT
 
 theorem posMulMono_iff_mulPosMono : PosMulMono α ↔ MulPosMono α := by
-  simp only [PosMulMono, MulPosMono, mul_comm]
+  simp only [PosMulMono, MulPosMono, IsSymmOp.symm_op]
 #align pos_mul_mono_iff_mul_pos_mono posMulMono_iff_mulPosMono
 
 theorem posMulMonoRev_iff_mulPosMonoRev : PosMulMonoRev α ↔ MulPosMonoRev α := by
-  simp only [PosMulMonoRev, MulPosMonoRev, mul_comm]
+  simp only [PosMulMonoRev, MulPosMonoRev, IsSymmOp.symm_op]
 #align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulMonoRev_iff_mulPosMonoRev
 
 end CommSemigroupHasZero

44e29dbc

style: a linter for colons (#6761)

A linter that throws on seeing a colon at the start of a line, according to the style guideline that says these operators should go before linebreaks.

69a3de31

Diff

@@ -813,8 +813,8 @@ theorem lt_mul_of_lt_of_one_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α
 /-! Lemmas of the form `a ≤ 1 → b ≤ c → a * b ≤ c`. -/
 
 
-theorem mul_le_of_le_one_of_le_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b ≤ c) (hb : 0 ≤ b)
-    : a * b ≤ c :=
+theorem mul_le_of_le_one_of_le_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b ≤ c) (hb : 0 ≤ b) :
+    a * b ≤ c :=
   (mul_le_of_le_one_left hb ha).trans h
 #align mul_le_of_le_one_of_le_of_nonneg mul_le_of_le_one_of_le_of_nonneg
 
@@ -922,8 +922,8 @@ theorem lt_of_lt_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a < b * c) (
   h.trans_le <| mul_le_of_le_one_left hc hb
 #align lt_of_lt_mul_of_le_one_of_nonneg_right lt_of_lt_mul_of_le_one_of_nonneg_right
 
-theorem le_mul_of_one_le_of_le_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (bc : b ≤ c) (c0 : 0 ≤ c)
-    : b ≤ a * c :=
+theorem le_mul_of_one_le_of_le_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (bc : b ≤ c) (c0 : 0 ≤ c) :
+    b ≤ a * c :=
   bc.trans <| le_mul_of_one_le_left c0 ha
 #align le_mul_of_one_le_of_le_of_nonneg le_mul_of_one_le_of_le_of_nonneg

44e29dbc

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -181,16 +181,16 @@ theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0
   @ContravariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
 #align le_of_mul_le_mul_right le_of_mul_le_mul_right
 
-alias lt_of_mul_lt_mul_left ← lt_of_mul_lt_mul_of_nonneg_left
+alias lt_of_mul_lt_mul_of_nonneg_left := lt_of_mul_lt_mul_left
 #align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_left
 
-alias lt_of_mul_lt_mul_right ← lt_of_mul_lt_mul_of_nonneg_right
+alias lt_of_mul_lt_mul_of_nonneg_right := lt_of_mul_lt_mul_right
 #align lt_of_mul_lt_mul_of_nonneg_right lt_of_mul_lt_mul_of_nonneg_right
 
-alias le_of_mul_le_mul_left ← le_of_mul_le_mul_of_pos_left
+alias le_of_mul_le_mul_of_pos_left := le_of_mul_le_mul_left
 #align le_of_mul_le_mul_of_pos_left le_of_mul_le_mul_of_pos_left
 
-alias le_of_mul_le_mul_right ← le_of_mul_le_mul_of_pos_right
+alias le_of_mul_le_mul_of_pos_right := le_of_mul_le_mul_right
 #align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_right
 
 @[simp]
@@ -338,7 +338,7 @@ theorem Left.mul_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b
   simpa only [mul_zero] using mul_lt_mul_of_pos_left hb ha
 #align left.mul_pos Left.mul_pos
 
-alias Left.mul_pos ← mul_pos
+alias mul_pos := Left.mul_pos
 #align mul_pos mul_pos
 
 theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) : a * b < 0 := by
@@ -373,7 +373,7 @@ theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a
   simpa only [mul_zero] using mul_le_mul_of_nonneg_left hb ha
 #align left.mul_nonneg Left.mul_nonneg
 
-alias Left.mul_nonneg ← mul_nonneg
+alias mul_nonneg := Left.mul_nonneg
 #align mul_nonneg mul_nonneg
 
 theorem mul_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0 := by

44e29dbc

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

@@ -49,7 +49,7 @@ The following is local notation in this file:
 -/
 
 
-variable (α : Type _)
+variable (α : Type*)
 
 -- mathport name: «exprα≥0»
 /- Notations for nonnegative and positive elements

44e29dbc

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,15 +2,12 @@
 Copyright (c) 2022 Damiano Testa. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa, Yuyang Zhao
-
-! This file was ported from Lean 3 source module algebra.order.ring.lemmas
-! leanprover-community/mathlib commit 44e29dbcff83ba7114a464d592b8c3743987c1e5
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.CovariantAndContravariant
 import Mathlib.Algebra.GroupWithZero.Defs
 
+#align_import algebra.order.ring.lemmas from "leanprover-community/mathlib"@"44e29dbcff83ba7114a464d592b8c3743987c1e5"
+
 /-!
 # Multiplication by ·positive· elements is monotonic

44e29dbc

chore: convert lambda in docs to fun (#5045)

Found with git grep -n "λ [a-zA-Z_ ]*,"

1164cf04

Diff

@@ -24,24 +24,24 @@ If the type `α` also has a multiplication, then we combine this with (`Contrava
 More specifically, we use extensively the following typeclasses:
 
 * monotone left
-* * `CovariantClass α>0 α (λ x y, x * y) (≤)`, abbreviated `PosMulMono α`,
+* * `CovariantClass α>0 α (fun x y ↦ x * y) (≤)`, abbreviated `PosMulMono α`,
     expressing that multiplication by positive elements on the left is monotone;
-* * `CovariantClass α>0 α (λ x y, x * y) (<)`, abbreviated `PosMulStrictMono α`,
+* * `CovariantClass α>0 α (fun x y ↦ x * y) (<)`, abbreviated `PosMulStrictMono α`,
     expressing that multiplication by positive elements on the left is strictly monotone;
 * monotone right
-* * `CovariantClass α>0 α (λ x y, y * x) (≤)`, abbreviated `MulPosMono α`,
+* * `CovariantClass α>0 α (fun x y ↦ y * x) (≤)`, abbreviated `MulPosMono α`,
     expressing that multiplication by positive elements on the right is monotone;
-* * `CovariantClass α>0 α (λ x y, y * x) (<)`, abbreviated `MulPosStrictMono α`,
+* * `CovariantClass α>0 α (fun x y ↦ y * x) (<)`, abbreviated `MulPosStrictMono α`,
     expressing that multiplication by positive elements on the right is strictly monotone.
 * reverse monotone left
-* * `ContravariantClass α>0 α (λ x y, x * y) (≤)`, abbreviated `PosMulMonoRev α`,
+* * `ContravariantClass α>0 α (fun x y ↦ x * y) (≤)`, abbreviated `PosMulMonoRev α`,
     expressing that multiplication by positive elements on the left is reverse monotone;
-* * `ContravariantClass α>0 α (λ x y, x * y) (<)`, abbreviated `PosMulReflectLT α`,
+* * `ContravariantClass α>0 α (fun x y ↦ x * y) (<)`, abbreviated `PosMulReflectLT α`,
     expressing that multiplication by positive elements on the left is strictly reverse monotone;
 * reverse reverse monotone right
-* * `ContravariantClass α>0 α (λ x y, y * x) (≤)`, abbreviated `MulPosMonoRev α`,
+* * `ContravariantClass α>0 α (fun x y ↦ y * x) (≤)`, abbreviated `MulPosMonoRev α`,
     expressing that multiplication by positive elements on the right is reverse monotone;
-* * `ContravariantClass α>0 α (λ x y, y * x) (<)`, abbreviated `MulPosReflectLT α`,
+* * `ContravariantClass α>0 α (fun x y ↦ y * x) (<)`, abbreviated `MulPosReflectLT α`,
     expressing that multiplication by positive elements on the right is strictly reverse monotone.
 
 ## Notation
@@ -72,49 +72,49 @@ set_option quotPrecheck false in
 /-- Local notation for the positive elements of a type `α`. TODO: actually make local. -/
 notation "α>0" => { x : α // 0 < x }
 
-/-- `PosMulMono α` is an abbreviation for `CovariantClass α≥0 α (λ x y, x * y) (≤)`,
+/-- `PosMulMono α` is an abbreviation for `CovariantClass α≥0 α (fun x y ↦ x * y) (≤)`,
 expressing that multiplication by nonnegative elements on the left is monotone. -/
 abbrev PosMulMono : Prop :=
   CovariantClass α≥0 α (fun x y => x * y) (· ≤ ·)
 #align pos_mul_mono PosMulMono
 
-/-- `MulPosMono α` is an abbreviation for `CovariantClass α≥0 α (λ x y, y * x) (≤)`,
+/-- `MulPosMono α` is an abbreviation for `CovariantClass α≥0 α (fun x y ↦ y * x) (≤)`,
 expressing that multiplication by nonnegative elements on the right is monotone. -/
 abbrev MulPosMono : Prop :=
   CovariantClass α≥0 α (fun x y => y * x) (· ≤ ·)
 #align mul_pos_mono MulPosMono
 
-/-- `PosMulStrictMono α` is an abbreviation for `CovariantClass α>0 α (λ x y, x * y) (<)`,
+/-- `PosMulStrictMono α` is an abbreviation for `CovariantClass α>0 α (fun x y ↦ x * y) (<)`,
 expressing that multiplication by positive elements on the left is strictly monotone. -/
 abbrev PosMulStrictMono : Prop :=
   CovariantClass α>0 α (fun x y => x * y) (· < ·)
 #align pos_mul_strict_mono PosMulStrictMono
 
-/-- `MulPosStrictMono α` is an abbreviation for `CovariantClass α>0 α (λ x y, y * x) (<)`,
+/-- `MulPosStrictMono α` is an abbreviation for `CovariantClass α>0 α (fun x y ↦ y * x) (<)`,
 expressing that multiplication by positive elements on the right is strictly monotone. -/
 abbrev MulPosStrictMono : Prop :=
   CovariantClass α>0 α (fun x y => y * x) (· < ·)
 #align mul_pos_strict_mono MulPosStrictMono
 
-/-- `PosMulReflectLT α` is an abbreviation for `ContravariantClas α≥0 α (λ x y, x * y) (<)`,
+/-- `PosMulReflectLT α` is an abbreviation for `ContravariantClas α≥0 α (fun x y ↦ x * y) (<)`,
 expressing that multiplication by nonnegative elements on the left is strictly reverse monotone. -/
 abbrev PosMulReflectLT : Prop :=
   ContravariantClass α≥0 α (fun x y => x * y) (· < ·)
 #align pos_mul_reflect_lt PosMulReflectLT
 
-/-- `MulPosReflectLT α` is an abbreviation for `ContravariantClas α≥0 α (λ x y, y * x) (<)`,
+/-- `MulPosReflectLT α` is an abbreviation for `ContravariantClas α≥0 α (fun x y ↦ y * x) (<)`,
 expressing that multiplication by nonnegative elements on the right is strictly reverse monotone. -/
 abbrev MulPosReflectLT : Prop :=
   ContravariantClass α≥0 α (fun x y => y * x) (· < ·)
 #align mul_pos_reflect_lt MulPosReflectLT
 
-/-- `PosMulMonoRev α` is an abbreviation for `ContravariantClas α>0 α (λ x y, x * y) (≤)`,
+/-- `PosMulMonoRev α` is an abbreviation for `ContravariantClas α>0 α (fun x y ↦ x * y) (≤)`,
 expressing that multiplication by positive elements on the left is reverse monotone. -/
 abbrev PosMulMonoRev : Prop :=
   ContravariantClass α>0 α (fun x y => x * y) (· ≤ ·)
 #align pos_mul_mono_rev PosMulMonoRev
 
-/-- `MulPosMonoRev α` is an abbreviation for `ContravariantClas α>0 α (λ x y, y * x) (≤)`,
+/-- `MulPosMonoRev α` is an abbreviation for `ContravariantClas α>0 α (fun x y ↦ y * x) (≤)`,
 expressing that multiplication by positive elements on the right is reverse monotone. -/
 abbrev MulPosMonoRev : Prop :=
   ContravariantClass α>0 α (fun x y => y * x) (· ≤ ·)

44e29dbc

chore: forward-port leanprover-community/mathlib#18831 (#3572)

8ad95dbd

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa, Yuyang Zhao
 
 ! This file was ported from Lean 3 source module algebra.order.ring.lemmas
-! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
+! leanprover-community/mathlib commit 44e29dbcff83ba7114a464d592b8c3743987c1e5
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -660,7 +660,10 @@ theorem mul_lt_iff_lt_one_left [MulPosStrictMono α] [MulPosReflectLT α] (b0 :
   Iff.trans (by rw [one_mul]) (mul_lt_mul_right b0)
 #align mul_lt_iff_lt_one_left mul_lt_iff_lt_one_left
 
-/-! Lemmas of the form `1 ≤ b → a ≤ a * b`. -/
+/-! Lemmas of the form `1 ≤ b → a ≤ a * b`.
+
+Variants with `< 0` and `≤ 0` instead of `0 <` and `0 ≤` appear in `Mathlib/Algebra/Order/Ring/Defs`
+(which imports this file) as they need additional results which are not yet available here. -/
 
 
 theorem mul_le_of_le_one_left [MulPosMono α] (hb : 0 ≤ b) (h : a ≤ 1) : a * b ≤ b := by

c4658a64

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

@@ -76,21 +76,25 @@ notation "α>0" => { x : α // 0 < x }
 expressing that multiplication by nonnegative elements on the left is monotone. -/
 abbrev PosMulMono : Prop :=
   CovariantClass α≥0 α (fun x y => x * y) (· ≤ ·)
+#align pos_mul_mono PosMulMono
 
 /-- `MulPosMono α` is an abbreviation for `CovariantClass α≥0 α (λ x y, y * x) (≤)`,
 expressing that multiplication by nonnegative elements on the right is monotone. -/
 abbrev MulPosMono : Prop :=
   CovariantClass α≥0 α (fun x y => y * x) (· ≤ ·)
+#align mul_pos_mono MulPosMono
 
 /-- `PosMulStrictMono α` is an abbreviation for `CovariantClass α>0 α (λ x y, x * y) (<)`,
 expressing that multiplication by positive elements on the left is strictly monotone. -/
 abbrev PosMulStrictMono : Prop :=
   CovariantClass α>0 α (fun x y => x * y) (· < ·)
+#align pos_mul_strict_mono PosMulStrictMono
 
 /-- `MulPosStrictMono α` is an abbreviation for `CovariantClass α>0 α (λ x y, y * x) (<)`,
 expressing that multiplication by positive elements on the right is strictly monotone. -/
 abbrev MulPosStrictMono : Prop :=
   CovariantClass α>0 α (fun x y => y * x) (· < ·)
+#align mul_pos_strict_mono MulPosStrictMono
 
 /-- `PosMulReflectLT α` is an abbreviation for `ContravariantClas α≥0 α (λ x y, x * y) (<)`,
 expressing that multiplication by nonnegative elements on the left is strictly reverse monotone. -/
@@ -108,11 +112,13 @@ abbrev MulPosReflectLT : Prop :=
 expressing that multiplication by positive elements on the left is reverse monotone. -/
 abbrev PosMulMonoRev : Prop :=
   ContravariantClass α>0 α (fun x y => x * y) (· ≤ ·)
+#align pos_mul_mono_rev PosMulMonoRev
 
 /-- `MulPosMonoRev α` is an abbreviation for `ContravariantClas α>0 α (λ x y, y * x) (≤)`,
 expressing that multiplication by positive elements on the right is reverse monotone. -/
 abbrev MulPosMonoRev : Prop :=
   ContravariantClass α>0 α (fun x y => y * x) (· ≤ ·)
+#align mul_pos_mono_rev MulPosMonoRev
 
 end Abbreviations
 
@@ -148,93 +154,119 @@ instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
 
 theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c :=
   @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
+#align mul_le_mul_of_nonneg_left mul_le_mul_of_nonneg_left
 
 theorem mul_le_mul_of_nonneg_right [MulPosMono α] (h : b ≤ c) (a0 : 0 ≤ a) : b * a ≤ c * a :=
   @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
+#align mul_le_mul_of_nonneg_right mul_le_mul_of_nonneg_right
 
 theorem mul_lt_mul_of_pos_left [PosMulStrictMono α] (bc : b < c) (a0 : 0 < a) : a * b < a * c :=
   @CovariantClass.elim α>0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ bc
+#align mul_lt_mul_of_pos_left mul_lt_mul_of_pos_left
 
 theorem mul_lt_mul_of_pos_right [MulPosStrictMono α] (bc : b < c) (a0 : 0 < a) : b * a < c * a :=
   @CovariantClass.elim α>0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ bc
+#align mul_lt_mul_of_pos_right mul_lt_mul_of_pos_right
 
 theorem lt_of_mul_lt_mul_left [PosMulReflectLT α] (h : a * b < a * c) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨a, a0⟩ _ _ h
+#align lt_of_mul_lt_mul_left lt_of_mul_lt_mul_left
 
 theorem lt_of_mul_lt_mul_right [MulPosReflectLT α] (h : b * a < c * a) (a0 : 0 ≤ a) : b < c :=
   @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨a, a0⟩ _ _ h
+#align lt_of_mul_lt_mul_right lt_of_mul_lt_mul_right
 
 theorem le_of_mul_le_mul_left [PosMulMonoRev α] (bc : a * b ≤ a * c) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
+#align le_of_mul_le_mul_left le_of_mul_le_mul_left
 
 theorem le_of_mul_le_mul_right [MulPosMonoRev α] (bc : b * a ≤ c * a) (a0 : 0 < a) : b ≤ c :=
   @ContravariantClass.elim α>0 α (fun x y => y * x) (· ≤ ·) _ ⟨a, a0⟩ _ _ bc
+#align le_of_mul_le_mul_right le_of_mul_le_mul_right
 
 alias lt_of_mul_lt_mul_left ← lt_of_mul_lt_mul_of_nonneg_left
+#align lt_of_mul_lt_mul_of_nonneg_left lt_of_mul_lt_mul_of_nonneg_left
 
 alias lt_of_mul_lt_mul_right ← lt_of_mul_lt_mul_of_nonneg_right
+#align lt_of_mul_lt_mul_of_nonneg_right lt_of_mul_lt_mul_of_nonneg_right
 
 alias le_of_mul_le_mul_left ← le_of_mul_le_mul_of_pos_left
+#align le_of_mul_le_mul_of_pos_left le_of_mul_le_mul_of_pos_left
 
 alias le_of_mul_le_mul_right ← le_of_mul_le_mul_of_pos_right
+#align le_of_mul_le_mul_of_pos_right le_of_mul_le_mul_of_pos_right
 
 @[simp]
 theorem mul_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a * b < a * c ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· < ·) _ _ ⟨a, a0⟩ _ _
+#align mul_lt_mul_left mul_lt_mul_left
 
 @[simp]
 theorem mul_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a) :
     b * a < c * a ↔ b < c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· < ·) _ _ ⟨a, a0⟩ _ _
+#align mul_lt_mul_right mul_lt_mul_right
 
 @[simp]
 theorem mul_le_mul_left [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a * c ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => x * y) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
+#align mul_le_mul_left mul_le_mul_left
 
 @[simp]
 theorem mul_le_mul_right [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : b * a ≤ c * a ↔ b ≤ c :=
   @rel_iff_cov α>0 α (fun x y => y * x) (· ≤ ·) _ _ ⟨a, a0⟩ _ _
+#align mul_le_mul_right mul_le_mul_right
 
 theorem mul_lt_mul_of_pos_of_nonneg [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 ≤ d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans_le (mul_le_mul_of_nonneg_right h₁ d0)
+#align mul_lt_mul_of_pos_of_nonneg mul_lt_mul_of_pos_of_nonneg
 
 theorem mul_lt_mul_of_le_of_le' [PosMulStrictMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 ≤ c) : a * c < b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans_lt (mul_lt_mul_of_pos_left h₂ b0)
+#align mul_lt_mul_of_le_of_le' mul_lt_mul_of_le_of_le'
 
 theorem mul_lt_mul_of_nonneg_of_pos [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (a0 : 0 ≤ a) (d0 : 0 < d) : a * c < b * d :=
   (mul_le_mul_of_nonneg_left h₂ a0).trans_lt (mul_lt_mul_of_pos_right h₁ d0)
+#align mul_lt_mul_of_nonneg_of_pos mul_lt_mul_of_nonneg_of_pos
 
 theorem mul_lt_mul_of_le_of_lt' [PosMulMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c ≤ d)
     (b0 : 0 ≤ b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans_le (mul_le_mul_of_nonneg_left h₂ b0)
+#align mul_lt_mul_of_le_of_lt' mul_lt_mul_of_le_of_lt'
 
 theorem mul_lt_mul_of_pos_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (a0 : 0 < a) (d0 : 0 < d) : a * c < b * d :=
   (mul_lt_mul_of_pos_left h₂ a0).trans (mul_lt_mul_of_pos_right h₁ d0)
+#align mul_lt_mul_of_pos_of_pos mul_lt_mul_of_pos_of_pos
 
 theorem mul_lt_mul_of_lt_of_lt' [PosMulStrictMono α] [MulPosStrictMono α] (h₁ : a < b) (h₂ : c < d)
     (b0 : 0 < b) (c0 : 0 < c) : a * c < b * d :=
   (mul_lt_mul_of_pos_right h₁ c0).trans (mul_lt_mul_of_pos_left h₂ b0)
+#align mul_lt_mul_of_lt_of_lt' mul_lt_mul_of_lt_of_lt'
 
 theorem mul_lt_of_mul_lt_of_nonneg_left [PosMulMono α] (h : a * b < c) (hdb : d ≤ b) (ha : 0 ≤ a) :
     a * d < c :=
   (mul_le_mul_of_nonneg_left hdb ha).trans_lt h
+#align mul_lt_of_mul_lt_of_nonneg_left mul_lt_of_mul_lt_of_nonneg_left
 
 theorem lt_mul_of_lt_mul_of_nonneg_left [PosMulMono α] (h : a < b * c) (hcd : c ≤ d) (hb : 0 ≤ b) :
     a < b * d :=
   h.trans_le <| mul_le_mul_of_nonneg_left hcd hb
+#align lt_mul_of_lt_mul_of_nonneg_left lt_mul_of_lt_mul_of_nonneg_left
 
 theorem mul_lt_of_mul_lt_of_nonneg_right [MulPosMono α] (h : a * b < c) (hda : d ≤ a) (hb : 0 ≤ b) :
     d * b < c :=
   (mul_le_mul_of_nonneg_right hda hb).trans_lt h
+#align mul_lt_of_mul_lt_of_nonneg_right mul_lt_of_mul_lt_of_nonneg_right
 
 theorem lt_mul_of_lt_mul_of_nonneg_right [MulPosMono α] (h : a < b * c) (hbd : b ≤ d) (hc : 0 ≤ c) :
     a < d * c :=
   h.trans_le <| mul_le_mul_of_nonneg_right hbd hc
+#align lt_mul_of_lt_mul_of_nonneg_right lt_mul_of_lt_mul_of_nonneg_right
 
 end Preorder
 
@@ -254,15 +286,19 @@ instance (priority := 100) MulPosStrictMono.toMulPosMonoRev [MulPosStrictMono α
 
 theorem PosMulMonoRev.toPosMulStrictMono [PosMulMonoRev α] : PosMulStrictMono α :=
   ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| le_of_mul_le_mul_of_pos_left h' x.prop⟩
+#align pos_mul_mono_rev.to_pos_mul_strict_mono PosMulMonoRev.toPosMulStrictMono
 
 theorem MulPosMonoRev.toMulPosStrictMono [MulPosMonoRev α] : MulPosStrictMono α :=
   ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| le_of_mul_le_mul_of_pos_right h' x.prop⟩
+#align mul_pos_mono_rev.to_mul_pos_strict_mono MulPosMonoRev.toMulPosStrictMono
 
 theorem posMulStrictMono_iff_posMulMonoRev : PosMulStrictMono α ↔ PosMulMonoRev α :=
   ⟨@PosMulStrictMono.toPosMulMonoRev _ _ _ _, @PosMulMonoRev.toPosMulStrictMono _ _ _ _⟩
+#align pos_mul_strict_mono_iff_pos_mul_mono_rev posMulStrictMono_iff_posMulMonoRev
 
 theorem mulPosStrictMono_iff_mulPosMonoRev : MulPosStrictMono α ↔ MulPosMonoRev α :=
   ⟨@MulPosStrictMono.toMulPosMonoRev _ _ _ _, @MulPosMonoRev.toMulPosStrictMono _ _ _ _⟩
+#align mul_pos_strict_mono_iff_mul_pos_mono_rev mulPosStrictMono_iff_mulPosMonoRev
 
 theorem PosMulReflectLT.toPosMulMono [PosMulReflectLT α] : PosMulMono α :=
   ⟨fun x _ _ h => le_of_not_lt fun h' => h.not_lt <| lt_of_mul_lt_mul_left h' x.prop⟩
@@ -274,15 +310,19 @@ theorem MulPosReflectLT.toMulPosMono [MulPosReflectLT α] : MulPosMono α :=
 
 theorem PosMulMono.toPosMulReflectLT [PosMulMono α] : PosMulReflectLT α :=
   ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| mul_le_mul_of_nonneg_left h' x.prop⟩
+#align pos_mul_mono.to_pos_mul_reflect_lt PosMulMono.toPosMulReflectLT
 
 theorem MulPosMono.toMulPosReflectLT [MulPosMono α] : MulPosReflectLT α :=
   ⟨fun x _ _ h => lt_of_not_ge fun h' => h.not_le <| mul_le_mul_of_nonneg_right h' x.prop⟩
+#align mul_pos_mono.to_mul_pos_reflect_lt MulPosMono.toMulPosReflectLT
 
 theorem posMulMono_iff_posMulReflectLT : PosMulMono α ↔ PosMulReflectLT α :=
   ⟨@PosMulMono.toPosMulReflectLT _ _ _ _, @PosMulReflectLT.toPosMulMono _ _ _ _⟩
+#align pos_mul_mono_iff_pos_mul_reflect_lt posMulMono_iff_posMulReflectLT
 
 theorem mulPosMono_iff_mulPosReflectLT : MulPosMono α ↔ MulPosReflectLT α :=
   ⟨@MulPosMono.toMulPosReflectLT _ _ _ _, @MulPosReflectLT.toMulPosMono _ _ _ _⟩
+#align mul_pos_mono_iff_mul_pos_reflect_lt mulPosMono_iff_mulPosReflectLT
 
 end LinearOrder
 
@@ -299,84 +339,106 @@ variable [Preorder α]
 /-- Assumes left covariance. -/
 theorem Left.mul_pos [PosMulStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
   simpa only [mul_zero] using mul_lt_mul_of_pos_left hb ha
+#align left.mul_pos Left.mul_pos
 
 alias Left.mul_pos ← mul_pos
+#align mul_pos mul_pos
 
 theorem mul_neg_of_pos_of_neg [PosMulStrictMono α] (ha : 0 < a) (hb : b < 0) : a * b < 0 := by
   simpa only [mul_zero] using mul_lt_mul_of_pos_left hb ha
+#align mul_neg_of_pos_of_neg mul_neg_of_pos_of_neg
 
 @[simp]
 theorem zero_lt_mul_left [PosMulStrictMono α] [PosMulReflectLT α] (h : 0 < c) :
     0 < c * b ↔ 0 < b := by
   rw [←mul_zero c, mul_lt_mul_left h]
   simp
+#align zero_lt_mul_left zero_lt_mul_left
 
 /-- Assumes right covariance. -/
 theorem Right.mul_pos [MulPosStrictMono α] (ha : 0 < a) (hb : 0 < b) : 0 < a * b := by
   simpa only [zero_mul] using mul_lt_mul_of_pos_right ha hb
+#align right.mul_pos Right.mul_pos
 
 theorem mul_neg_of_neg_of_pos [MulPosStrictMono α] (ha : a < 0) (hb : 0 < b) : a * b < 0 := by
   simpa only [zero_mul] using mul_lt_mul_of_pos_right ha hb
+#align mul_neg_of_neg_of_pos mul_neg_of_neg_of_pos
 
 @[simp]
 theorem zero_lt_mul_right [MulPosStrictMono α] [MulPosReflectLT α] (h : 0 < c) :
     0 < b * c ↔ 0 < b := by
   rw [←zero_mul c, mul_lt_mul_right h]
   simp
+#align zero_lt_mul_right zero_lt_mul_right
 
 /-- Assumes left covariance. -/
 theorem Left.mul_nonneg [PosMulMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
   simpa only [mul_zero] using mul_le_mul_of_nonneg_left hb ha
+#align left.mul_nonneg Left.mul_nonneg
 
 alias Left.mul_nonneg ← mul_nonneg
+#align mul_nonneg mul_nonneg
 
 theorem mul_nonpos_of_nonneg_of_nonpos [PosMulMono α] (ha : 0 ≤ a) (hb : b ≤ 0) : a * b ≤ 0 := by
   simpa only [mul_zero] using mul_le_mul_of_nonneg_left hb ha
+#align mul_nonpos_of_nonneg_of_nonpos mul_nonpos_of_nonneg_of_nonpos
 
 /-- Assumes right covariance. -/
 theorem Right.mul_nonneg [MulPosMono α] (ha : 0 ≤ a) (hb : 0 ≤ b) : 0 ≤ a * b := by
   simpa only [zero_mul] using mul_le_mul_of_nonneg_right ha hb
+#align right.mul_nonneg Right.mul_nonneg
 
 theorem mul_nonpos_of_nonpos_of_nonneg [MulPosMono α] (ha : a ≤ 0) (hb : 0 ≤ b) : a * b ≤ 0 := by
   simpa only [zero_mul] using mul_le_mul_of_nonneg_right ha hb
+#align mul_nonpos_of_nonpos_of_nonneg mul_nonpos_of_nonpos_of_nonneg
 
 theorem pos_of_mul_pos_right [PosMulReflectLT α] (h : 0 < a * b) (ha : 0 ≤ a) : 0 < b :=
   lt_of_mul_lt_mul_left ((mul_zero a).symm ▸ h : a * 0 < a * b) ha
+#align pos_of_mul_pos_right pos_of_mul_pos_right
 
 theorem pos_of_mul_pos_left [MulPosReflectLT α] (h : 0 < a * b) (hb : 0 ≤ b) : 0 < a :=
   lt_of_mul_lt_mul_right ((zero_mul b).symm ▸ h : 0 * b < a * b) hb
+#align pos_of_mul_pos_left pos_of_mul_pos_left
 
 theorem pos_iff_pos_of_mul_pos [PosMulReflectLT α] [MulPosReflectLT α] (hab : 0 < a * b) :
     0 < a ↔ 0 < b :=
   ⟨pos_of_mul_pos_right hab ∘ le_of_lt, pos_of_mul_pos_left hab ∘ le_of_lt⟩
+#align pos_iff_pos_of_mul_pos pos_iff_pos_of_mul_pos
 
 theorem mul_le_mul_of_le_of_le [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (a0 : 0 ≤ a)
     (d0 : 0 ≤ d) : a * c ≤ b * d :=
   (mul_le_mul_of_nonneg_left h₂ a0).trans <| mul_le_mul_of_nonneg_right h₁ d0
+#align mul_le_mul_of_le_of_le mul_le_mul_of_le_of_le
 
 theorem mul_le_mul [PosMulMono α] [MulPosMono α] (h₁ : a ≤ b) (h₂ : c ≤ d) (c0 : 0 ≤ c)
     (b0 : 0 ≤ b) : a * c ≤ b * d :=
   (mul_le_mul_of_nonneg_right h₁ c0).trans <| mul_le_mul_of_nonneg_left h₂ b0
+#align mul_le_mul mul_le_mul
 
 theorem mul_self_le_mul_self [PosMulMono α] [MulPosMono α] (ha : 0 ≤ a) (hab : a ≤ b) :
     a * a ≤ b * b :=
   mul_le_mul hab hab ha <| ha.trans hab
+#align mul_self_le_mul_self mul_self_le_mul_self
 
 theorem mul_le_of_mul_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hle : d ≤ b)
     (a0 : 0 ≤ a) : a * d ≤ c :=
   (mul_le_mul_of_nonneg_left hle a0).trans h
+#align mul_le_of_mul_le_of_nonneg_left mul_le_of_mul_le_of_nonneg_left
 
 theorem le_mul_of_le_mul_of_nonneg_left [PosMulMono α] (h : a ≤ b * c) (hle : c ≤ d)
     (b0 : 0 ≤ b) : a ≤ b * d :=
   h.trans (mul_le_mul_of_nonneg_left hle b0)
+#align le_mul_of_le_mul_of_nonneg_left le_mul_of_le_mul_of_nonneg_left
 
 theorem mul_le_of_mul_le_of_nonneg_right [MulPosMono α] (h : a * b ≤ c) (hle : d ≤ a)
     (b0 : 0 ≤ b) : d * b ≤ c :=
   (mul_le_mul_of_nonneg_right hle b0).trans h
+#align mul_le_of_mul_le_of_nonneg_right mul_le_of_mul_le_of_nonneg_right
 
 theorem le_mul_of_le_mul_of_nonneg_right [MulPosMono α] (h : a ≤ b * c) (hle : b ≤ d)
     (c0 : 0 ≤ c) : a ≤ d * c :=
   h.trans (mul_le_mul_of_nonneg_right hle c0)
+#align le_mul_of_le_mul_of_nonneg_right le_mul_of_le_mul_of_nonneg_right
 
 end Preorder
 
@@ -459,10 +521,12 @@ instance (priority := 100) MulPosMonoRev.toMulPosReflectLT [MulPosMonoRev α] :
 theorem mul_left_cancel_iff_of_pos [PosMulMonoRev α] (a0 : 0 < a) : a * b = a * c ↔ b = c :=
   ⟨fun h => (le_of_mul_le_mul_of_pos_left h.le a0).antisymm <|
     le_of_mul_le_mul_of_pos_left h.ge a0, congr_arg _⟩
+#align mul_left_cancel_iff_of_pos mul_left_cancel_iff_of_pos
 
 theorem mul_right_cancel_iff_of_pos [MulPosMonoRev α] (b0 : 0 < b) : a * b = c * b ↔ a = c :=
   ⟨fun h => (le_of_mul_le_mul_of_pos_right h.le b0).antisymm <|
     le_of_mul_le_mul_of_pos_right h.ge b0, congr_arg (· * b)⟩
+#align mul_right_cancel_iff_of_pos mul_right_cancel_iff_of_pos
 
 theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
     [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (a0 : 0 < a) (d0 : 0 < d) :
@@ -470,11 +534,10 @@ theorem mul_eq_mul_iff_eq_and_eq_of_pos [PosMulStrictMono α] [MulPosStrictMono
   refine' ⟨fun h => _, fun h => congr_arg₂ (· * ·) h.1 h.2⟩
   rcases hac.eq_or_lt with (rfl | hac)
   · exact ⟨rfl, (mul_left_cancel_iff_of_pos a0).mp h⟩
-
   rcases eq_or_lt_of_le hbd with (rfl | hbd)
   · exact ⟨(mul_right_cancel_iff_of_pos d0).mp h, rfl⟩
-
   exact ((mul_lt_mul_of_pos_of_pos hac hbd a0 d0).ne h).elim
+#align mul_eq_mul_iff_eq_and_eq_of_pos mul_eq_mul_iff_eq_and_eq_of_pos
 
 theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono α] [PosMulMonoRev α]
     [MulPosMonoRev α] (hac : a ≤ b) (hbd : c ≤ d) (b0 : 0 < b) (c0 : 0 < c) :
@@ -482,11 +545,10 @@ theorem mul_eq_mul_iff_eq_and_eq_of_pos' [PosMulStrictMono α] [MulPosStrictMono
   refine' ⟨fun h => _, fun h => congr_arg₂ (· * ·) h.1 h.2⟩
   rcases hac.eq_or_lt with (rfl | hac)
   · exact ⟨rfl, (mul_left_cancel_iff_of_pos b0).mp h⟩
-
   rcases eq_or_lt_of_le hbd with (rfl | hbd)
   · exact ⟨(mul_right_cancel_iff_of_pos c0).mp h, rfl⟩
-
   exact ((mul_lt_mul_of_lt_of_lt' hac hbd b0 c0).ne h).elim
+#align mul_eq_mul_iff_eq_and_eq_of_pos' mul_eq_mul_iff_eq_and_eq_of_pos'
 
 end PartialOrder
 
@@ -503,28 +565,36 @@ theorem pos_and_pos_or_neg_and_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (h
     exact hab.false.elim
   · refine' Or.inl ⟨ha, lt_imp_lt_of_le_imp_le (fun hb => _) hab⟩
     exact mul_nonpos_of_nonneg_of_nonpos ha.le hb
+#align pos_and_pos_or_neg_and_neg_of_mul_pos pos_and_pos_or_neg_and_neg_of_mul_pos
 
 
 theorem neg_of_mul_pos_right [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha : a ≤ 0) : b < 0 :=
   ((pos_and_pos_or_neg_and_neg_of_mul_pos h).resolve_left fun h => h.1.not_le ha).2
+#align neg_of_mul_pos_right neg_of_mul_pos_right
 
 theorem neg_of_mul_pos_left [PosMulMono α] [MulPosMono α] (h : 0 < a * b) (ha : b ≤ 0) : a < 0 :=
   ((pos_and_pos_or_neg_and_neg_of_mul_pos h).resolve_left fun h => h.2.not_le ha).1
+#align neg_of_mul_pos_left neg_of_mul_pos_left
 
 theorem neg_iff_neg_of_mul_pos [PosMulMono α] [MulPosMono α] (hab : 0 < a * b) : a < 0 ↔ b < 0 :=
   ⟨neg_of_mul_pos_right hab ∘ le_of_lt, neg_of_mul_pos_left hab ∘ le_of_lt⟩
+#align neg_iff_neg_of_mul_pos neg_iff_neg_of_mul_pos
 
 theorem Left.neg_of_mul_neg_left [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ a) : b < 0 :=
   lt_of_not_ge fun h2 : b ≥ 0 => (Left.mul_nonneg h1 h2).not_lt h
+#align left.neg_of_mul_neg_left Left.neg_of_mul_neg_left
 
 theorem Right.neg_of_mul_neg_left [MulPosMono α] (h : a * b < 0) (h1 : 0 ≤ a) : b < 0 :=
   lt_of_not_ge fun h2 : b ≥ 0 => (Right.mul_nonneg h1 h2).not_lt h
+#align right.neg_of_mul_neg_left Right.neg_of_mul_neg_left
 
 theorem Left.neg_of_mul_neg_right [PosMulMono α] (h : a * b < 0) (h1 : 0 ≤ b) : a < 0 :=
   lt_of_not_ge fun h2 : a ≥ 0 => (Left.mul_nonneg h2 h1).not_lt h
+#align left.neg_of_mul_neg_right Left.neg_of_mul_neg_right
 
 theorem Right.neg_of_mul_neg_right [MulPosMono α] (h : a * b < 0) (h1 : 0 ≤ b) : a < 0 :=
   lt_of_not_ge fun h2 : a ≥ 0 => (Right.mul_nonneg h2 h1).not_lt h
+#align right.neg_of_mul_neg_right Right.neg_of_mul_neg_right
 
 end LinearOrder
 
@@ -545,20 +615,24 @@ which assume left covariance. -/
 @[simp]
 theorem le_mul_iff_one_le_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a ≤ a * b ↔ 1 ≤ b :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
+#align le_mul_iff_one_le_right le_mul_iff_one_le_right
 
 @[simp]
 theorem lt_mul_iff_one_lt_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a < a * b ↔ 1 < b :=
   Iff.trans (by rw [mul_one]) (mul_lt_mul_left a0)
+#align lt_mul_iff_one_lt_right lt_mul_iff_one_lt_right
 
 @[simp]
 theorem mul_le_iff_le_one_right [PosMulMono α] [PosMulMonoRev α] (a0 : 0 < a) : a * b ≤ a ↔ b ≤ 1 :=
   Iff.trans (by rw [mul_one]) (mul_le_mul_left a0)
+#align mul_le_iff_le_one_right mul_le_iff_le_one_right
 
 @[simp]
 theorem mul_lt_iff_lt_one_right [PosMulStrictMono α] [PosMulReflectLT α] (a0 : 0 < a) :
     a * b < a ↔ b < 1 :=
   Iff.trans (by rw [mul_one]) (mul_lt_mul_left a0)
+#align mul_lt_iff_lt_one_right mul_lt_iff_lt_one_right
 
 /-! Lemmas of the form `a ≤ b * a ↔ 1 ≤ b` and `a * b ≤ b ↔ a ≤ 1`,
 which assume right covariance. -/
@@ -567,47 +641,59 @@ which assume right covariance. -/
 @[simp]
 theorem le_mul_iff_one_le_left [MulPosMono α] [MulPosMonoRev α] (a0 : 0 < a) : a ≤ b * a ↔ 1 ≤ b :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right a0)
+#align le_mul_iff_one_le_left le_mul_iff_one_le_left
 
 @[simp]
 theorem lt_mul_iff_one_lt_left [MulPosStrictMono α] [MulPosReflectLT α] (a0 : 0 < a) :
     a < b * a ↔ 1 < b :=
   Iff.trans (by rw [one_mul]) (mul_lt_mul_right a0)
+#align lt_mul_iff_one_lt_left lt_mul_iff_one_lt_left
 
 @[simp]
 theorem mul_le_iff_le_one_left [MulPosMono α] [MulPosMonoRev α] (b0 : 0 < b) : a * b ≤ b ↔ a ≤ 1 :=
   Iff.trans (by rw [one_mul]) (mul_le_mul_right b0)
+#align mul_le_iff_le_one_left mul_le_iff_le_one_left
 
 @[simp]
 theorem mul_lt_iff_lt_one_left [MulPosStrictMono α] [MulPosReflectLT α] (b0 : 0 < b) :
     a * b < b ↔ a < 1 :=
   Iff.trans (by rw [one_mul]) (mul_lt_mul_right b0)
+#align mul_lt_iff_lt_one_left mul_lt_iff_lt_one_left
 
 /-! Lemmas of the form `1 ≤ b → a ≤ a * b`. -/
 
 
 theorem mul_le_of_le_one_left [MulPosMono α] (hb : 0 ≤ b) (h : a ≤ 1) : a * b ≤ b := by
   simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
+#align mul_le_of_le_one_left mul_le_of_le_one_left
 
 theorem le_mul_of_one_le_left [MulPosMono α] (hb : 0 ≤ b) (h : 1 ≤ a) : b ≤ a * b := by
   simpa only [one_mul] using mul_le_mul_of_nonneg_right h hb
+#align le_mul_of_one_le_left le_mul_of_one_le_left
 
 theorem mul_le_of_le_one_right [PosMulMono α] (ha : 0 ≤ a) (h : b ≤ 1) : a * b ≤ a := by
   simpa only [mul_one] using mul_le_mul_of_nonneg_left h ha
+#align mul_le_of_le_one_right mul_le_of_le_one_right
 
 theorem le_mul_of_one_le_right [PosMulMono α] (ha : 0 ≤ a) (h : 1 ≤ b) : a ≤ a * b := by
   simpa only [mul_one] using mul_le_mul_of_nonneg_left h ha
+#align le_mul_of_one_le_right le_mul_of_one_le_right
 
 theorem mul_lt_of_lt_one_left [MulPosStrictMono α] (hb : 0 < b) (h : a < 1) : a * b < b := by
   simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
+#align mul_lt_of_lt_one_left mul_lt_of_lt_one_left
 
 theorem lt_mul_of_one_lt_left [MulPosStrictMono α] (hb : 0 < b) (h : 1 < a) : b < a * b := by
   simpa only [one_mul] using mul_lt_mul_of_pos_right h hb
+#align lt_mul_of_one_lt_left lt_mul_of_one_lt_left
 
 theorem mul_lt_of_lt_one_right [PosMulStrictMono α] (ha : 0 < a) (h : b < 1) : a * b < a := by
   simpa only [mul_one] using mul_lt_mul_of_pos_left h ha
+#align mul_lt_of_lt_one_right mul_lt_of_lt_one_right
 
 theorem lt_mul_of_one_lt_right [PosMulStrictMono α] (ha : 0 < a) (h : 1 < b) : a < a * b := by
   simpa only [mul_one] using mul_lt_mul_of_pos_left h ha
+#align lt_mul_of_one_lt_right lt_mul_of_one_lt_right
 
 /-! Lemmas of the form `b ≤ c → a ≤ 1 → b * a ≤ c`. -/
 
@@ -618,45 +704,55 @@ to find -/
 theorem mul_le_of_le_of_le_one_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : a ≤ 1) (hb : 0 ≤ b) :
     b * a ≤ c :=
   (mul_le_of_le_one_right hb ha).trans h
+#align mul_le_of_le_of_le_one_of_nonneg mul_le_of_le_of_le_one_of_nonneg
 
 theorem mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha : a < 1) (b0 : 0 < b) :
     b * a < c :=
   (mul_lt_of_lt_one_right b0 ha).trans_le bc
+#align mul_lt_of_le_of_lt_one_of_pos mul_lt_of_le_of_lt_one_of_pos
 
 theorem mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (h : b < c) (ha : a ≤ 1) (hb : 0 ≤ b) :
     b * a < c :=
   (mul_le_of_le_one_right hb ha).trans_lt h
+#align mul_lt_of_lt_of_le_one_of_nonneg mul_lt_of_lt_of_le_one_of_nonneg
 
 /-- Assumes left covariance. -/
 theorem Left.mul_le_one_of_le_of_le [PosMulMono α] (ha : a ≤ 1) (hb : b ≤ 1) (a0 : 0 ≤ a) :
     a * b ≤ 1 :=
   mul_le_of_le_of_le_one_of_nonneg ha hb a0
+#align left.mul_le_one_of_le_of_le Left.mul_le_one_of_le_of_le
 
 /-- Assumes left covariance. -/
 theorem Left.mul_lt_of_le_of_lt_one_of_pos [PosMulStrictMono α] (ha : a ≤ 1) (hb : b < 1)
     (a0 : 0 < a) : a * b < 1 :=
   _root_.mul_lt_of_le_of_lt_one_of_pos ha hb a0
+#align left.mul_lt_of_le_of_lt_one_of_pos Left.mul_lt_of_le_of_lt_one_of_pos
 
 /-- Assumes left covariance. -/
 theorem Left.mul_lt_of_lt_of_le_one_of_nonneg [PosMulMono α] (ha : a < 1) (hb : b ≤ 1)
     (a0 : 0 ≤ a) : a * b < 1 :=
   _root_.mul_lt_of_lt_of_le_one_of_nonneg ha hb a0
+#align left.mul_lt_of_lt_of_le_one_of_nonneg Left.mul_lt_of_lt_of_le_one_of_nonneg
 
 theorem mul_le_of_le_of_le_one' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (ha : a ≤ 1) (a0 : 0 ≤ a)
     (c0 : 0 ≤ c) : b * a ≤ c :=
   (mul_le_mul_of_nonneg_right bc a0).trans <| mul_le_of_le_one_right c0 ha
+#align mul_le_of_le_of_le_one' mul_le_of_le_of_le_one'
 
 theorem mul_lt_of_lt_of_le_one' [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : a ≤ 1)
     (a0 : 0 < a) (c0 : 0 ≤ c) : b * a < c :=
   (mul_lt_mul_of_pos_right bc a0).trans_le <| mul_le_of_le_one_right c0 ha
+#align mul_lt_of_lt_of_le_one' mul_lt_of_lt_of_le_one'
 
 theorem mul_lt_of_le_of_lt_one' [PosMulStrictMono α] [MulPosMono α] (bc : b ≤ c) (ha : a < 1)
     (a0 : 0 ≤ a) (c0 : 0 < c) : b * a < c :=
   (mul_le_mul_of_nonneg_right bc a0).trans_lt <| mul_lt_of_lt_one_right c0 ha
+#align mul_lt_of_le_of_lt_one' mul_lt_of_le_of_lt_one'
 
 theorem mul_lt_of_lt_of_lt_one_of_pos [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : a ≤ 1)
     (a0 : 0 < a) (c0 : 0 ≤ c) : b * a < c :=
   (mul_lt_mul_of_pos_right bc a0).trans_le <| mul_le_of_le_one_right c0 ha
+#align mul_lt_of_lt_of_lt_one_of_pos mul_lt_of_lt_of_lt_one_of_pos
 
 /-! Lemmas of the form `b ≤ c → 1 ≤ a → b ≤ c * a`. -/
 
@@ -664,45 +760,55 @@ theorem mul_lt_of_lt_of_lt_one_of_pos [PosMulMono α] [MulPosStrictMono α] (bc
 theorem le_mul_of_le_of_one_le_of_nonneg [PosMulMono α] (h : b ≤ c) (ha : 1 ≤ a) (hc : 0 ≤ c) :
     b ≤ c * a :=
   h.trans <| le_mul_of_one_le_right hc ha
+#align le_mul_of_le_of_one_le_of_nonneg le_mul_of_le_of_one_le_of_nonneg
 
 theorem lt_mul_of_le_of_one_lt_of_pos [PosMulStrictMono α] (bc : b ≤ c) (ha : 1 < a) (c0 : 0 < c) :
     b < c * a :=
   bc.trans_lt <| lt_mul_of_one_lt_right c0 ha
+#align lt_mul_of_le_of_one_lt_of_pos lt_mul_of_le_of_one_lt_of_pos
 
 theorem lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (h : b < c) (ha : 1 ≤ a) (hc : 0 ≤ c) :
     b < c * a :=
   h.trans_le <| le_mul_of_one_le_right hc ha
+#align lt_mul_of_lt_of_one_le_of_nonneg lt_mul_of_lt_of_one_le_of_nonneg
 
 /-- Assumes left covariance. -/
 theorem Left.one_le_mul_of_le_of_le [PosMulMono α] (ha : 1 ≤ a) (hb : 1 ≤ b) (a0 : 0 ≤ a) :
     1 ≤ a * b :=
   le_mul_of_le_of_one_le_of_nonneg ha hb a0
+#align left.one_le_mul_of_le_of_le Left.one_le_mul_of_le_of_le
 
 /-- Assumes left covariance. -/
 theorem Left.one_lt_mul_of_le_of_lt_of_pos [PosMulStrictMono α] (ha : 1 ≤ a) (hb : 1 < b)
     (a0 : 0 < a) : 1 < a * b :=
   lt_mul_of_le_of_one_lt_of_pos ha hb a0
+#align left.one_lt_mul_of_le_of_lt_of_pos Left.one_lt_mul_of_le_of_lt_of_pos
 
 /-- Assumes left covariance. -/
 theorem Left.lt_mul_of_lt_of_one_le_of_nonneg [PosMulMono α] (ha : 1 < a) (hb : 1 ≤ b)
     (a0 : 0 ≤ a) : 1 < a * b :=
   _root_.lt_mul_of_lt_of_one_le_of_nonneg ha hb a0
+#align left.lt_mul_of_lt_of_one_le_of_nonneg Left.lt_mul_of_lt_of_one_le_of_nonneg
 
 theorem le_mul_of_le_of_one_le' [PosMulMono α] [MulPosMono α] (bc : b ≤ c) (ha : 1 ≤ a)
     (a0 : 0 ≤ a) (b0 : 0 ≤ b) : b ≤ c * a :=
   (le_mul_of_one_le_right b0 ha).trans <| mul_le_mul_of_nonneg_right bc a0
+#align le_mul_of_le_of_one_le' le_mul_of_le_of_one_le'
 
 theorem lt_mul_of_le_of_one_lt' [PosMulStrictMono α] [MulPosMono α] (bc : b ≤ c) (ha : 1 < a)
     (a0 : 0 ≤ a) (b0 : 0 < b) : b < c * a :=
   (lt_mul_of_one_lt_right b0 ha).trans_le <| mul_le_mul_of_nonneg_right bc a0
+#align lt_mul_of_le_of_one_lt' lt_mul_of_le_of_one_lt'
 
 theorem lt_mul_of_lt_of_one_le' [PosMulMono α] [MulPosStrictMono α] (bc : b < c) (ha : 1 ≤ a)
     (a0 : 0 < a) (b0 : 0 ≤ b) : b < c * a :=
   (le_mul_of_one_le_right b0 ha).trans_lt <| mul_lt_mul_of_pos_right bc a0
+#align lt_mul_of_lt_of_one_le' lt_mul_of_lt_of_one_le'
 
 theorem lt_mul_of_lt_of_one_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (bc : b < c)
     (ha : 1 < a) (a0 : 0 < a) (b0 : 0 < b) : b < c * a :=
   (lt_mul_of_one_lt_right b0 ha).trans <| mul_lt_mul_of_pos_right bc a0
+#align lt_mul_of_lt_of_one_lt_of_pos lt_mul_of_lt_of_one_lt_of_pos
 
 /-! Lemmas of the form `a ≤ 1 → b ≤ c → a * b ≤ c`. -/
 
@@ -710,45 +816,55 @@ theorem lt_mul_of_lt_of_one_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α
 theorem mul_le_of_le_one_of_le_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b ≤ c) (hb : 0 ≤ b)
     : a * b ≤ c :=
   (mul_le_of_le_one_left hb ha).trans h
+#align mul_le_of_le_one_of_le_of_nonneg mul_le_of_le_one_of_le_of_nonneg
 
 theorem mul_lt_of_lt_one_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (h : b ≤ c) (hb : 0 < b) :
     a * b < c :=
   (mul_lt_of_lt_one_left hb ha).trans_le h
+#align mul_lt_of_lt_one_of_le_of_pos mul_lt_of_lt_one_of_le_of_pos
 
 theorem mul_lt_of_le_one_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (h : b < c) (hb : 0 ≤ b) :
     a * b < c :=
   (mul_le_of_le_one_left hb ha).trans_lt h
+#align mul_lt_of_le_one_of_lt_of_nonneg mul_lt_of_le_one_of_lt_of_nonneg
 
 /-- Assumes right covariance. -/
 theorem Right.mul_lt_one_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : a < 1) (hb : b ≤ 1)
     (b0 : 0 < b) : a * b < 1 :=
   mul_lt_of_lt_one_of_le_of_pos ha hb b0
+#align right.mul_lt_one_of_lt_of_le_of_pos Right.mul_lt_one_of_lt_of_le_of_pos
 
 /-- Assumes right covariance. -/
 theorem Right.mul_lt_one_of_le_of_lt_of_nonneg [MulPosMono α] (ha : a ≤ 1) (hb : b < 1)
     (b0 : 0 ≤ b) : a * b < 1 :=
   mul_lt_of_le_one_of_lt_of_nonneg ha hb b0
+#align right.mul_lt_one_of_le_of_lt_of_nonneg Right.mul_lt_one_of_le_of_lt_of_nonneg
 
 theorem mul_lt_of_lt_one_of_lt_of_pos [PosMulStrictMono α] [MulPosStrictMono α] (ha : a < 1)
     (bc : b < c) (a0 : 0 < a) (c0 : 0 < c) : a * b < c :=
   (mul_lt_mul_of_pos_left bc a0).trans <| mul_lt_of_lt_one_left c0 ha
+#align mul_lt_of_lt_one_of_lt_of_pos mul_lt_of_lt_one_of_lt_of_pos
 
 /-- Assumes right covariance. -/
 theorem Right.mul_le_one_of_le_of_le [MulPosMono α] (ha : a ≤ 1) (hb : b ≤ 1) (b0 : 0 ≤ b) :
     a * b ≤ 1 :=
   mul_le_of_le_one_of_le_of_nonneg ha hb b0
+#align right.mul_le_one_of_le_of_le Right.mul_le_one_of_le_of_le
 
 theorem mul_le_of_le_one_of_le' [PosMulMono α] [MulPosMono α] (ha : a ≤ 1) (bc : b ≤ c) (a0 : 0 ≤ a)
     (c0 : 0 ≤ c) : a * b ≤ c :=
   (mul_le_mul_of_nonneg_left bc a0).trans <| mul_le_of_le_one_left c0 ha
+#align mul_le_of_le_one_of_le' mul_le_of_le_one_of_le'
 
 theorem mul_lt_of_lt_one_of_le' [PosMulMono α] [MulPosStrictMono α] (ha : a < 1) (bc : b ≤ c)
     (a0 : 0 ≤ a) (c0 : 0 < c) : a * b < c :=
   (mul_le_mul_of_nonneg_left bc a0).trans_lt <| mul_lt_of_lt_one_left c0 ha
+#align mul_lt_of_lt_one_of_le' mul_lt_of_lt_one_of_le'
 
 theorem mul_lt_of_le_one_of_lt' [PosMulStrictMono α] [MulPosMono α] (ha : a ≤ 1) (bc : b < c)
     (a0 : 0 < a) (c0 : 0 ≤ c) : a * b < c :=
   (mul_lt_mul_of_pos_left bc a0).trans_le <| mul_le_of_le_one_left c0 ha
+#align mul_lt_of_le_one_of_lt' mul_lt_of_le_one_of_lt'
 
 /-! Lemmas of the form `1 ≤ a → b ≤ c → b ≤ a * c`. -/
 
@@ -756,70 +872,86 @@ theorem mul_lt_of_le_one_of_lt' [PosMulStrictMono α] [MulPosMono α] (ha : a 
 theorem lt_mul_of_one_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b ≤ c) (hc : 0 < c) :
     b < a * c :=
   h.trans_lt <| lt_mul_of_one_lt_left hc ha
+#align lt_mul_of_one_lt_of_le_of_pos lt_mul_of_one_lt_of_le_of_pos
 
 theorem lt_mul_of_one_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b < c) (hc : 0 ≤ c) :
     b < a * c :=
   h.trans_le <| le_mul_of_one_le_left hc ha
+#align lt_mul_of_one_le_of_lt_of_nonneg lt_mul_of_one_le_of_lt_of_nonneg
 
 theorem lt_mul_of_one_lt_of_lt_of_pos [MulPosStrictMono α] (ha : 1 < a) (h : b < c) (hc : 0 < c) :
     b < a * c :=
   h.trans <| lt_mul_of_one_lt_left hc ha
+#align lt_mul_of_one_lt_of_lt_of_pos lt_mul_of_one_lt_of_lt_of_pos
 
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_lt_of_le_of_pos [MulPosStrictMono α] (ha : 1 < a) (hb : 1 ≤ b)
     (b0 : 0 < b) : 1 < a * b :=
   lt_mul_of_one_lt_of_le_of_pos ha hb b0
+#align right.one_lt_mul_of_lt_of_le_of_pos Right.one_lt_mul_of_lt_of_le_of_pos
 
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_le_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (hb : 1 < b)
     (b0 : 0 ≤ b) : 1 < a * b :=
   lt_mul_of_one_le_of_lt_of_nonneg ha hb b0
+#align right.one_lt_mul_of_le_of_lt_of_nonneg Right.one_lt_mul_of_le_of_lt_of_nonneg
 
 /-- Assumes right covariance. -/
 theorem Right.one_lt_mul_of_lt_of_lt [MulPosStrictMono α] (ha : 1 < a) (hb : 1 < b) (b0 : 0 < b) :
     1 < a * b :=
   lt_mul_of_one_lt_of_lt_of_pos ha hb b0
+#align right.one_lt_mul_of_lt_of_lt Right.one_lt_mul_of_lt_of_lt
 
 theorem lt_mul_of_one_lt_of_lt_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (h : b < c) (hc : 0 ≤ c) :
     b < a * c :=
   h.trans_le <| le_mul_of_one_le_left hc ha
+#align lt_mul_of_one_lt_of_lt_of_nonneg lt_mul_of_one_lt_of_lt_of_nonneg
 
 theorem lt_of_mul_lt_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b < c) (hle : 1 ≤ b)
     (ha : 0 ≤ a) : a < c :=
   (le_mul_of_one_le_right ha hle).trans_lt h
+#align lt_of_mul_lt_of_one_le_of_nonneg_left lt_of_mul_lt_of_one_le_of_nonneg_left
 
 theorem lt_of_lt_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a < b * c) (hc : c ≤ 1)
     (hb : 0 ≤ b) : a < b :=
   h.trans_le <| mul_le_of_le_one_right hb hc
+#align lt_of_lt_mul_of_le_one_of_nonneg_left lt_of_lt_mul_of_le_one_of_nonneg_left
 
 theorem lt_of_lt_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a < b * c) (hb : b ≤ 1)
     (hc : 0 ≤ c) : a < c :=
   h.trans_le <| mul_le_of_le_one_left hc hb
+#align lt_of_lt_mul_of_le_one_of_nonneg_right lt_of_lt_mul_of_le_one_of_nonneg_right
 
 theorem le_mul_of_one_le_of_le_of_nonneg [MulPosMono α] (ha : 1 ≤ a) (bc : b ≤ c) (c0 : 0 ≤ c)
     : b ≤ a * c :=
   bc.trans <| le_mul_of_one_le_left c0 ha
+#align le_mul_of_one_le_of_le_of_nonneg le_mul_of_one_le_of_le_of_nonneg
 
 /-- Assumes right covariance. -/
 theorem Right.one_le_mul_of_le_of_le [MulPosMono α] (ha : 1 ≤ a) (hb : 1 ≤ b) (b0 : 0 ≤ b) :
     1 ≤ a * b :=
   le_mul_of_one_le_of_le_of_nonneg ha hb b0
+#align right.one_le_mul_of_le_of_le Right.one_le_mul_of_le_of_le
 
 theorem le_of_mul_le_of_one_le_of_nonneg_left [PosMulMono α] (h : a * b ≤ c) (hb : 1 ≤ b)
     (ha : 0 ≤ a) : a ≤ c :=
   (le_mul_of_one_le_right ha hb).trans h
+#align le_of_mul_le_of_one_le_of_nonneg_left le_of_mul_le_of_one_le_of_nonneg_left
 
 theorem le_of_le_mul_of_le_one_of_nonneg_left [PosMulMono α] (h : a ≤ b * c) (hc : c ≤ 1)
     (hb : 0 ≤ b) : a ≤ b :=
   h.trans <| mul_le_of_le_one_right hb hc
+#align le_of_le_mul_of_le_one_of_nonneg_left le_of_le_mul_of_le_one_of_nonneg_left
 
 theorem le_of_mul_le_of_one_le_nonneg_right [MulPosMono α] (h : a * b ≤ c) (ha : 1 ≤ a)
     (hb : 0 ≤ b) : b ≤ c :=
   (le_mul_of_one_le_left hb ha).trans h
+#align le_of_mul_le_of_one_le_nonneg_right le_of_mul_le_of_one_le_nonneg_right
 
 theorem le_of_le_mul_of_le_one_of_nonneg_right [MulPosMono α] (h : a ≤ b * c) (hb : b ≤ 1)
     (hc : 0 ≤ c) : a ≤ c :=
   h.trans <| mul_le_of_le_one_left hc hb
+#align le_of_le_mul_of_le_one_of_nonneg_right le_of_le_mul_of_le_one_of_nonneg_right
 
 end Preorder
 
@@ -833,6 +965,7 @@ theorem exists_square_le' [PosMulStrictMono α] (a0 : 0 < a) : ∃ b : α, b * b
   obtain ha | ha := lt_or_le a 1
   · exact ⟨a, (mul_lt_of_lt_one_right a0 ha).le⟩
   · exact ⟨1, by rwa [mul_one]⟩
+#align exists_square_le' exists_square_le'
 
 end LinearOrder

c4658a64

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

54af0498

Diff

@@ -139,14 +139,12 @@ instance MulPosMono.to_covariantClass_pos_mul_le [MulPosMono α] :
 instance PosMulReflectLT.to_contravariantClass_pos_mul_lt [PosMulReflectLT α] :
     ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
   ⟨fun a _ _ bc => @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
-#align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt
-  PosMulReflectLT.to_contravariantClass_pos_mul_lt
+#align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt PosMulReflectLT.to_contravariantClass_pos_mul_lt
 
 instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
     ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
   ⟨fun a _ _ bc => @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
-#align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt
-  MulPosReflectLT.to_contravariantClass_pos_mul_lt
+#align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt MulPosReflectLT.to_contravariantClass_pos_mul_lt
 
 theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c :=
   @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ h

c4658a64

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

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

72b23bd4

Diff

@@ -894,19 +894,19 @@ section CommSemigroupHasZero
 variable [CommSemigroup α] [Zero α] [Preorder α]
 
 theorem posMulStrictMono_iff_mulPosStrictMono : PosMulStrictMono α ↔ MulPosStrictMono α := by
-  simp only [PosMulStrictMono, MulPosStrictMono, mul_comm, iff_self]
+  simp only [PosMulStrictMono, MulPosStrictMono, mul_comm]
 #align pos_mul_strict_mono_iff_mul_pos_strict_mono posMulStrictMono_iff_mulPosStrictMono
 
 theorem posMulReflectLT_iff_mulPosReflectLT : PosMulReflectLT α ↔ MulPosReflectLT α := by
-  simp only [PosMulReflectLT, MulPosReflectLT, mul_comm, iff_self]
+  simp only [PosMulReflectLT, MulPosReflectLT, mul_comm]
 #align pos_mul_reflect_lt_iff_mul_pos_reflect_lt posMulReflectLT_iff_mulPosReflectLT
 
 theorem posMulMono_iff_mulPosMono : PosMulMono α ↔ MulPosMono α := by
-  simp only [PosMulMono, MulPosMono, mul_comm, iff_self]
+  simp only [PosMulMono, MulPosMono, mul_comm]
 #align pos_mul_mono_iff_mul_pos_mono posMulMono_iff_mulPosMono
 
 theorem posMulMonoRev_iff_mulPosMonoRev : PosMulMonoRev α ↔ MulPosMonoRev α := by
-  simp only [PosMulMonoRev, MulPosMonoRev, mul_comm, iff_self]
+  simp only [PosMulMonoRev, MulPosMonoRev, mul_comm]
 #align pos_mul_mono_rev_iff_mul_pos_mono_rev posMulMonoRev_iff_mulPosMonoRev
 
 end CommSemigroupHasZero

c4658a64

chore: fix more casing errors per naming scheme (#1232)

I've avoided anything under Tactic or test.

In correcting the names, I found Option.isNone_iff_eq_none duplicated between Std and Mathlib, so the Mathlib one has been removed.

Co-authored-by: Reid Barton <rwbarton@gmail.com>

31a56f75

Diff

@@ -126,27 +126,27 @@ section Preorder
 
 variable [Preorder α]
 
-instance PosMulMono.toCovariantClassPosMulLE [PosMulMono α] :
+instance PosMulMono.to_covariantClass_pos_mul_le [PosMulMono α] :
     CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
   ⟨fun a _ _ bc => @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
-#align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.toCovariantClassPosMulLE
+#align pos_mul_mono.to_covariant_class_pos_mul_le PosMulMono.to_covariantClass_pos_mul_le
 
-instance MulPosMono.toCovariantClassPosMulLE [MulPosMono α] :
+instance MulPosMono.to_covariantClass_pos_mul_le [MulPosMono α] :
     CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
   ⟨fun a _ _ bc => @CovariantClass.elim α≥0 α (fun x y => y * x) (· ≤ ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
-#align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.toCovariantClassPosMulLE
+#align mul_pos_mono.to_covariant_class_pos_mul_le MulPosMono.to_covariantClass_pos_mul_le
 
-instance PosMulReflectLT.toContravariantClassPosMulLT [PosMulReflectLT α] :
+instance PosMulReflectLT.to_contravariantClass_pos_mul_lt [PosMulReflectLT α] :
     ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
   ⟨fun a _ _ bc => @ContravariantClass.elim α≥0 α (fun x y => x * y) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align pos_mul_reflect_lt.to_contravariant_class_pos_mul_lt
-  PosMulReflectLT.toContravariantClassPosMulLT
+  PosMulReflectLT.to_contravariantClass_pos_mul_lt
 
-instance MulPosReflectLT.toContravariantClassPosMulLT [MulPosReflectLT α] :
+instance MulPosReflectLT.to_contravariantClass_pos_mul_lt [MulPosReflectLT α] :
     ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
   ⟨fun a _ _ bc => @ContravariantClass.elim α≥0 α (fun x y => y * x) (· < ·) _ ⟨_, a.2.le⟩ _ _ bc⟩
 #align mul_pos_reflect_lt.to_contravariant_class_pos_mul_lt
-  MulPosReflectLT.toContravariantClassPosMulLT
+  MulPosReflectLT.to_contravariantClass_pos_mul_lt
 
 theorem mul_le_mul_of_nonneg_left [PosMulMono α] (h : b ≤ c) (a0 : 0 ≤ a) : a * b ≤ a * c :=
   @CovariantClass.elim α≥0 α (fun x y => x * y) (· ≤ ·) _ ⟨a, a0⟩ _ _ h
@@ -388,7 +388,7 @@ variable [PartialOrder α]
 
 theorem posMulMono_iff_covariant_pos :
     PosMulMono α ↔ CovariantClass α>0 α (fun x y => x * y) (· ≤ ·) :=
-  ⟨@PosMulMono.toCovariantClassPosMulLE _ _ _ _, fun h =>
+  ⟨@PosMulMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
       · simp [←ha]
@@ -397,7 +397,7 @@ theorem posMulMono_iff_covariant_pos :
 
 theorem mulPosMono_iff_covariant_pos :
     MulPosMono α ↔ CovariantClass α>0 α (fun x y => y * x) (· ≤ ·) :=
-  ⟨@MulPosMono.toCovariantClassPosMulLE _ _ _ _, fun h =>
+  ⟨@MulPosMono.to_covariantClass_pos_mul_le _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
       · simp [←ha]
@@ -406,7 +406,7 @@ theorem mulPosMono_iff_covariant_pos :
 
 theorem posMulReflectLT_iff_contravariant_pos :
     PosMulReflectLT α ↔ ContravariantClass α>0 α (fun x y => x * y) (· < ·) :=
-  ⟨@PosMulReflectLT.toContravariantClassPosMulLT _ _ _ _, fun h =>
+  ⟨@PosMulReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
       · simp [←ha] at h
@@ -415,7 +415,7 @@ theorem posMulReflectLT_iff_contravariant_pos :
 
 theorem mulPosReflectLT_iff_contravariant_pos :
     MulPosReflectLT α ↔ ContravariantClass α>0 α (fun x y => y * x) (· < ·) :=
-  ⟨@MulPosReflectLT.toContravariantClassPosMulLT _ _ _ _, fun h =>
+  ⟨@MulPosReflectLT.to_contravariantClass_pos_mul_lt _ _ _ _, fun h =>
     ⟨fun a b c h => by
       obtain ha | ha := a.prop.eq_or_lt
       · simp [←ha] at h

c4658a64

chore: add source headers to ported theory files (#1094)

The script used to do this is included. The yaml file was obtained from https://raw.githubusercontent.com/wiki/leanprover-community/mathlib/mathlib4-port-status.md

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2022 Damiano Testa. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Damiano Testa, Yuyang Zhao
+
+! This file was ported from Lean 3 source module algebra.order.ring.lemmas
+! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Algebra.CovariantAndContravariant
 import Mathlib.Algebra.GroupWithZero.Defs

`algebra.order.ring.lemmas` ⟷ `Mathlib.Algebra.Order.Ring.Lemmas`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 24

algebra.order.ring.lemmas ⟷ Mathlib.Algebra.Order.Ring.Lemmas

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 24

`algebra.order.ring.lemmas` ⟷ `Mathlib.Algebra.Order.Ring.Lemmas`