algebra.order.monoid.min_max | 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

de87d505

(last sync)

feat(algebra/order/monoid/min_max): a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂ (#18667)

Complete the API.

Diff

@@ -13,6 +13,8 @@ import algebra.order.monoid.lemmas
 > Any changes to this file require a corresponding PR to mathlib4.
 -/
 
+open function
+
 variables {α β : Type*}
 
 /-! Some lemmas about types that have an ordering and a binary operation, with no
@@ -43,26 +45,6 @@ variable [covariant_class α α (*) (≤)]
 lemma max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c :=
 (monotone_id.const_mul' a).map_max.symm
 
-@[to_additive]
-lemma lt_or_lt_of_mul_lt_mul [covariant_class α α (function.swap (*)) (≤)]
-  {a b m n : α} (h : m * n < a * b) :
-  m < a ∨ n < b :=
-by { contrapose! h, exact mul_le_mul' h.1 h.2 }
-
-@[to_additive]
-lemma mul_lt_mul_iff_of_le_of_le
-  [covariant_class α α (function.swap (*)) (<)]
-  [covariant_class α α (*) (<)]
-  [covariant_class α α (function.swap (*)) (≤)]
-  {a b c d : α} (ac : a ≤ c) (bd : b ≤ d) :
-  a * b < c * d ↔ (a < c) ∨ (b < d) :=
-begin
-  refine ⟨lt_or_lt_of_mul_lt_mul, λ h, _⟩,
-  cases h with ha hb,
-  { exact mul_lt_mul_of_lt_of_le ha bd },
-  { exact mul_lt_mul_of_le_of_lt ac hb }
-end
-
 end left
 
 section right
@@ -78,6 +60,37 @@ lemma max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
 
 end right
 
+@[to_additive] lemma lt_or_lt_of_mul_lt_mul [covariant_class α α (*) (≤)]
+  [covariant_class α α (swap (*)) (≤)] {a₁ a₂ b₁ b₂ : α} :
+  a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ :=
+by { contrapose!, exact λ h, mul_le_mul' h.1 h.2 }
+
+@[to_additive] lemma le_or_lt_of_mul_le_mul [covariant_class α α (*) (≤)]
+  [covariant_class α α (swap (*)) (<)] {a₁ a₂ b₁ b₂ : α} :
+  a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ :=
+by { contrapose!, exact λ h, mul_lt_mul_of_lt_of_le h.1 h.2 }
+
+@[to_additive] lemma lt_or_le_of_mul_le_mul [covariant_class α α (*) (<)]
+  [covariant_class α α (swap (*)) (≤)]  {a₁ a₂ b₁ b₂ : α} :
+  a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂ :=
+by { contrapose!, exact λ h, mul_lt_mul_of_le_of_lt h.1 h.2 }
+
+@[to_additive] lemma le_or_le_of_mul_le_mul [covariant_class α α (*) (<)]
+  [covariant_class α α (swap (*)) (<)] {a₁ a₂ b₁ b₂ : α} :
+  a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂ :=
+by { contrapose!, exact λ h, mul_lt_mul_of_lt_of_lt h.1 h.2 }
+
+@[to_additive] lemma mul_lt_mul_iff_of_le_of_le  [covariant_class α α (*) (≤)]
+  [covariant_class α α (swap (*)) (≤)] [covariant_class α α (*) (<)]
+  [covariant_class α α (swap (*)) (<)] {a₁ a₂ b₁ b₂ : α} (ha : a₁ ≤ a₂) (hb : b₁ ≤ b₂) :
+  a₁ * b₁ < a₂ * b₂ ↔ a₁ < a₂ ∨ b₁ < b₂ :=
+begin
+  refine ⟨lt_or_lt_of_mul_lt_mul, _⟩,
+  rintro (ha | hb),
+  { exact mul_lt_mul_of_lt_of_le ha hb },
+  { exact mul_lt_mul_of_le_of_lt ha hb }
+end
+
 end has_mul
 
 variable [mul_one_class α]

70d50ecf

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

de87d505

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) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
-import Mathbin.Order.MinMax
-import Mathbin.Algebra.Order.Monoid.Lemmas
+import Order.MinMax
+import Algebra.Order.Monoid.Lemmas
 
 #align_import algebra.order.monoid.min_max from "leanprover-community/mathlib"@"de87d5053a9fe5cbde723172c0fb7e27e7436473"

de87d505

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) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-
-! This file was ported from Lean 3 source module algebra.order.monoid.min_max
-! leanprover-community/mathlib commit de87d5053a9fe5cbde723172c0fb7e27e7436473
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.MinMax
 import Mathbin.Algebra.Order.Monoid.Lemmas
 
+#align_import algebra.order.monoid.min_max from "leanprover-community/mathlib"@"de87d5053a9fe5cbde723172c0fb7e27e7436473"
+
 /-!
 # Lemmas about `min` and `max` in an ordered monoid.

de87d505

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -27,17 +27,21 @@ variable {α β : Type _}
   rules relating them. -/
 
 
+#print fn_min_mul_fn_max /-
 @[to_additive]
 theorem fn_min_mul_fn_max [LinearOrder α] [CommSemigroup β] (f : α → β) (n m : α) :
     f (min n m) * f (max n m) = f n * f m := by cases' le_total n m with h h <;> simp [h, mul_comm]
 #align fn_min_mul_fn_max fn_min_mul_fn_max
 #align fn_min_add_fn_max fn_min_add_fn_max
+-/
 
+#print min_mul_max /-
 @[to_additive]
 theorem min_mul_max [LinearOrder α] [CommSemigroup α] (n m : α) : min n m * max n m = n * m :=
   fn_min_mul_fn_max id n m
 #align min_mul_max min_mul_max
 #align min_add_max min_add_max
+-/
 
 section CovariantClassMulLe
 
@@ -51,17 +55,21 @@ section Left
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
+#print min_mul_mul_left /-
 @[to_additive]
 theorem min_mul_mul_left (a b c : α) : min (a * b) (a * c) = a * min b c :=
   (monotone_id.const_mul' a).map_min.symm
 #align min_mul_mul_left min_mul_mul_left
 #align min_add_add_left min_add_add_left
+-/
 
+#print max_mul_mul_left /-
 @[to_additive]
 theorem max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c :=
   (monotone_id.const_mul' a).map_max.symm
 #align max_mul_mul_left max_mul_mul_left
 #align max_add_add_left max_add_add_left
+-/
 
 end Left
 
@@ -69,17 +77,21 @@ section Right
 
 variable [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)]
 
+#print min_mul_mul_right /-
 @[to_additive]
 theorem min_mul_mul_right (a b c : α) : min (a * c) (b * c) = min a b * c :=
   (monotone_id.mul_const' c).map_min.symm
 #align min_mul_mul_right min_mul_mul_right
 #align min_add_add_right min_add_add_right
+-/
 
+#print max_mul_mul_right /-
 @[to_additive]
 theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
   (monotone_id.mul_const' c).map_max.symm
 #align max_mul_mul_right max_mul_mul_right
 #align max_add_add_right max_add_add_right
+-/
 
 end Right
 
@@ -141,20 +153,25 @@ end Mul
 
 variable [MulOneClass α]
 
+#print min_le_mul_of_one_le_right /-
 @[to_additive]
 theorem min_le_mul_of_one_le_right [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} (hb : 1 ≤ b) :
     min a b ≤ a * b :=
   min_le_iff.2 <| Or.inl <| le_mul_of_one_le_right' hb
 #align min_le_mul_of_one_le_right min_le_mul_of_one_le_right
 #align min_le_add_of_nonneg_right min_le_add_of_nonneg_right
+-/
 
+#print min_le_mul_of_one_le_left /-
 @[to_additive]
 theorem min_le_mul_of_one_le_left [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b : α}
     (ha : 1 ≤ a) : min a b ≤ a * b :=
   min_le_iff.2 <| Or.inr <| le_mul_of_one_le_left' ha
 #align min_le_mul_of_one_le_left min_le_mul_of_one_le_left
 #align min_le_add_of_nonneg_left min_le_add_of_nonneg_left
+-/
 
+#print max_le_mul_of_one_le /-
 @[to_additive]
 theorem max_le_mul_of_one_le [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b : α} (ha : 1 ≤ a) (hb : 1 ≤ b) :
@@ -162,6 +179,7 @@ theorem max_le_mul_of_one_le [CovariantClass α α (· * ·) (· ≤ ·)]
   max_le_iff.2 ⟨le_mul_of_one_le_right' hb, le_mul_of_one_le_left' ha⟩
 #align max_le_mul_of_one_le max_le_mul_of_one_le
 #align max_le_add_of_nonneg max_le_add_of_nonneg
+-/
 
 end CovariantClassMulLe

de87d505

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -83,13 +83,16 @@ theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
 
 end Right
 
+#print lt_or_lt_of_mul_lt_mul /-
 @[to_additive]
 theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
     a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ := by contrapose!; exact fun h => mul_le_mul' h.1 h.2
 #align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
 #align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
+-/
 
+#print le_or_lt_of_mul_le_mul /-
 @[to_additive]
 theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -97,7 +100,9 @@ theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
   exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
 #align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mul
 #align le_or_lt_of_add_le_add le_or_lt_of_add_le_add
+-/
 
+#print lt_or_le_of_mul_le_mul /-
 @[to_additive]
 theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -105,7 +110,9 @@ theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
   exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
 #align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mul
 #align lt_or_le_of_add_le_add lt_or_le_of_add_le_add
+-/
 
+#print le_or_le_of_mul_le_mul /-
 @[to_additive]
 theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -113,7 +120,9 @@ theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
   exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
 #align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mul
 #align le_or_le_of_add_le_add le_or_le_of_add_le_add
+-/
 
+#print mul_lt_mul_iff_of_le_of_le /-
 @[to_additive]
 theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [CovariantClass α α (· * ·) (· < ·)]
@@ -126,6 +135,7 @@ theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
   · exact mul_lt_mul_of_le_of_lt ha hb
 #align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
 #align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
+-/
 
 end Mul

de87d505

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -27,24 +27,12 @@ variable {α β : Type _}
   rules relating them. -/
 
 
-/- warning: fn_min_mul_fn_max -> fn_min_mul_fn_max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : CommSemigroup.{u2} β] (f : α -> β) (n : α) (m : α), Eq.{succ u2} β (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β (Semigroup.toHasMul.{u2} β (CommSemigroup.toSemigroup.{u2} β _inst_2))) (f (LinearOrder.min.{u1} α _inst_1 n m)) (f (LinearOrder.max.{u1} α _inst_1 n m))) (HMul.hMul.{u2, u2, u2} β β β (instHMul.{u2} β (Semigroup.toHasMul.{u2} β (CommSemigroup.toSemigroup.{u2} β _inst_2))) (f n) (f m))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : CommSemigroup.{u1} β] (f : α -> β) (n : α) (m : α), Eq.{succ u1} β (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (Semigroup.toMul.{u1} β (CommSemigroup.toSemigroup.{u1} β _inst_2))) (f (Min.min.{u2} α (LinearOrder.toMin.{u2} α _inst_1) n m)) (f (Max.max.{u2} α (LinearOrder.toMax.{u2} α _inst_1) n m))) (HMul.hMul.{u1, u1, u1} β β β (instHMul.{u1} β (Semigroup.toMul.{u1} β (CommSemigroup.toSemigroup.{u1} β _inst_2))) (f n) (f m))
-Case conversion may be inaccurate. Consider using '#align fn_min_mul_fn_max fn_min_mul_fn_maxₓ'. -/
 @[to_additive]
 theorem fn_min_mul_fn_max [LinearOrder α] [CommSemigroup β] (f : α → β) (n m : α) :
     f (min n m) * f (max n m) = f n * f m := by cases' le_total n m with h h <;> simp [h, mul_comm]
 #align fn_min_mul_fn_max fn_min_mul_fn_max
 #align fn_min_add_fn_max fn_min_add_fn_max
 
-/- warning: min_mul_max -> min_mul_max is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : CommSemigroup.{u1} α] (n : α) (m : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_2))) (LinearOrder.min.{u1} α _inst_1 n m) (LinearOrder.max.{u1} α _inst_1 n m)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toHasMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_2))) n m)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : CommSemigroup.{u1} α] (n : α) (m : α), Eq.{succ u1} α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_2))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) n m) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) n m)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (Semigroup.toMul.{u1} α (CommSemigroup.toSemigroup.{u1} α _inst_2))) n m)
-Case conversion may be inaccurate. Consider using '#align min_mul_max min_mul_maxₓ'. -/
 @[to_additive]
 theorem min_mul_max [LinearOrder α] [CommSemigroup α] (n m : α) : min n m * max n m = n * m :=
   fn_min_mul_fn_max id n m
@@ -63,24 +51,12 @@ section Left
 
 variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
-/- warning: min_mul_mul_left -> min_mul_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.min.{u1} α _inst_1 b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.181 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.183 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.181 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.183) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.196 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.198 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.196 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.198)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) b c))
-Case conversion may be inaccurate. Consider using '#align min_mul_mul_left min_mul_mul_leftₓ'. -/
 @[to_additive]
 theorem min_mul_mul_left (a b c : α) : min (a * b) (a * c) = a * min b c :=
   (monotone_id.const_mul' a).map_min.symm
 #align min_mul_mul_left min_mul_mul_left
 #align min_add_add_left min_add_add_left
 
-/- warning: max_mul_mul_left -> max_mul_mul_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.max.{u1} α _inst_1 b c))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.257 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.259 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.257 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.259) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.272 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.274 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.272 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.274)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) b c))
-Case conversion may be inaccurate. Consider using '#align max_mul_mul_left max_mul_mul_leftₓ'. -/
 @[to_additive]
 theorem max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c :=
   (monotone_id.const_mul' a).map_max.symm
@@ -93,24 +69,12 @@ section Right
 
 variable [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)]
 
-/- warning: min_mul_mul_right -> min_mul_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.min.{u1} α _inst_1 a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.385 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.387 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.385 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.387)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.400 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.402 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.400 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.402)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) c)
-Case conversion may be inaccurate. Consider using '#align min_mul_mul_right min_mul_mul_rightₓ'. -/
 @[to_additive]
 theorem min_mul_mul_right (a b c : α) : min (a * c) (b * c) = min a b * c :=
   (monotone_id.mul_const' c).map_min.symm
 #align min_mul_mul_right min_mul_mul_right
 #align min_add_add_right min_add_add_right
 
-/- warning: max_mul_mul_right -> max_mul_mul_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.max.{u1} α _inst_1 a b) c)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.464 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.466 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.464 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.466)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.479 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.481 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.479 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.481)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) c)
-Case conversion may be inaccurate. Consider using '#align max_mul_mul_right max_mul_mul_rightₓ'. -/
 @[to_additive]
 theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
   (monotone_id.mul_const' c).map_max.symm
@@ -119,12 +83,6 @@ theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
 
 end Right
 
-/- warning: lt_or_lt_of_mul_lt_mul -> lt_or_lt_of_mul_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.541 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.543 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.541 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.543) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.556 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.558 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.556 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.558)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.578 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.580 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.578 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.580)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.593 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.595 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.593 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.595)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
-Case conversion may be inaccurate. Consider using '#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mulₓ'. -/
 @[to_additive]
 theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -132,12 +90,6 @@ theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
 #align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
 #align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
 
-/- warning: le_or_lt_of_mul_le_mul -> le_or_lt_of_mul_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.672 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.674 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.672 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.674) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.687 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.689 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.687 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.689)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.709 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.711 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.709 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.711)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.724 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.726 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.724 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.726)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
-Case conversion may be inaccurate. Consider using '#align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mulₓ'. -/
 @[to_additive]
 theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -146,12 +98,6 @@ theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
 #align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mul
 #align le_or_lt_of_add_le_add le_or_lt_of_add_le_add
 
-/- warning: lt_or_le_of_mul_le_mul -> lt_or_le_of_mul_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.803 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.805 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.803 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.805) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.818 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.820 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.818 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.820)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.840 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.842 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.840 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.842)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.855 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.857 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.855 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.857)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
-Case conversion may be inaccurate. Consider using '#align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mulₓ'. -/
 @[to_additive]
 theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -160,12 +106,6 @@ theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
 #align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mul
 #align lt_or_le_of_add_le_add lt_or_le_of_add_le_add
 
-/- warning: le_or_le_of_mul_le_mul -> le_or_le_of_mul_le_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.934 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.936 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.934 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.936) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.949 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.951 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.949 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.951)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.971 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.973 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.971 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.973)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.986 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.988 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.986 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.988)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
-Case conversion may be inaccurate. Consider using '#align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mulₓ'. -/
 @[to_additive]
 theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -174,12 +114,6 @@ theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
 #align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mul
 #align le_or_le_of_add_le_add le_or_le_of_add_le_add
 
-/- warning: mul_lt_mul_iff_of_le_of_le -> mul_lt_mul_iff_of_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_5 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) (Or (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1065 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1067 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1065 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1067) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1080 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1082 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1080 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1082)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1102 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1104 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1102 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1104)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1117 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1119 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1117 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1119)] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1136 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1138 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1136 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1138) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1151 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1153 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1151 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1153)] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1173 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1175 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1173 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1175)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1188 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1190 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1188 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1190)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂)))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_leₓ'. -/
 @[to_additive]
 theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [CovariantClass α α (· * ·) (· < ·)]
@@ -197,12 +131,6 @@ end Mul
 
 variable [MulOneClass α]
 
-/- warning: min_le_mul_of_one_le_right -> min_le_mul_of_one_le_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1296 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1298 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1296 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1298) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1311 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1313 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1311 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1313)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
-Case conversion may be inaccurate. Consider using '#align min_le_mul_of_one_le_right min_le_mul_of_one_le_rightₓ'. -/
 @[to_additive]
 theorem min_le_mul_of_one_le_right [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} (hb : 1 ≤ b) :
     min a b ≤ a * b :=
@@ -210,12 +138,6 @@ theorem min_le_mul_of_one_le_right [CovariantClass α α (· * ·) (· ≤ ·)]
 #align min_le_mul_of_one_le_right min_le_mul_of_one_le_right
 #align min_le_add_of_nonneg_right min_le_add_of_nonneg_right
 
-/- warning: min_le_mul_of_one_le_left -> min_le_mul_of_one_le_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1368 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1370 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1368 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1370)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1383 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1385 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1383 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1385)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
-Case conversion may be inaccurate. Consider using '#align min_le_mul_of_one_le_left min_le_mul_of_one_le_leftₓ'. -/
 @[to_additive]
 theorem min_le_mul_of_one_le_left [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b : α}
     (ha : 1 ≤ a) : min a b ≤ a * b :=
@@ -223,12 +145,6 @@ theorem min_le_mul_of_one_le_left [CovariantClass α α (Function.swap (· * ·)
 #align min_le_mul_of_one_le_left min_le_mul_of_one_le_left
 #align min_le_add_of_nonneg_left min_le_add_of_nonneg_left
 
-/- warning: max_le_mul_of_one_le -> max_le_mul_of_one_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.max.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1437 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1439 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1437 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1439) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1452 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1454 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1452 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1454)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1474 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1476 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1474 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1476)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1489 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1491 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1489 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1491)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
-Case conversion may be inaccurate. Consider using '#align max_le_mul_of_one_le max_le_mul_of_one_leₓ'. -/
 @[to_additive]
 theorem max_le_mul_of_one_le [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b : α} (ha : 1 ≤ a) (hb : 1 ≤ b) :

de87d505

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -128,10 +128,7 @@ Case conversion may be inaccurate. Consider using '#align lt_or_lt_of_mul_lt_mul
 @[to_additive]
 theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
-    a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ :=
-  by
-  contrapose!
-  exact fun h => mul_le_mul' h.1 h.2
+    a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ := by contrapose!; exact fun h => mul_le_mul' h.1 h.2
 #align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
 #align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
 
@@ -144,9 +141,7 @@ Case conversion may be inaccurate. Consider using '#align le_or_lt_of_mul_le_mul
 @[to_additive]
 theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
-    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ :=
-  by
-  contrapose!
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ := by contrapose!;
   exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
 #align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mul
 #align le_or_lt_of_add_le_add le_or_lt_of_add_le_add
@@ -160,9 +155,7 @@ Case conversion may be inaccurate. Consider using '#align lt_or_le_of_mul_le_mul
 @[to_additive]
 theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
-    a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂ :=
-  by
-  contrapose!
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂ := by contrapose!;
   exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
 #align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mul
 #align lt_or_le_of_add_le_add lt_or_le_of_add_le_add
@@ -176,9 +169,7 @@ Case conversion may be inaccurate. Consider using '#align le_or_le_of_mul_le_mul
 @[to_additive]
 theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
-    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂ :=
-  by
-  contrapose!
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂ := by contrapose!;
   exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
 #align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mul
 #align le_or_le_of_add_le_add le_or_le_of_add_le_add

de87d505

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -65,7 +65,7 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 
 /- warning: min_mul_mul_left -> min_mul_mul_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.min.{u1} α _inst_1 b c))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.min.{u1} α _inst_1 b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.181 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.183 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.181 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.183) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.196 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.198 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.196 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.198)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) b c))
 Case conversion may be inaccurate. Consider using '#align min_mul_mul_left min_mul_mul_leftₓ'. -/
@@ -77,7 +77,7 @@ theorem min_mul_mul_left (a b c : α) : min (a * b) (a * c) = a * min b c :=
 
 /- warning: max_mul_mul_left -> max_mul_mul_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.max.{u1} α _inst_1 b c))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.max.{u1} α _inst_1 b c))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.257 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.259 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.257 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.259) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.272 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.274 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.272 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.274)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) b c))
 Case conversion may be inaccurate. Consider using '#align max_mul_mul_left max_mul_mul_leftₓ'. -/
@@ -95,7 +95,7 @@ variable [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)]
 
 /- warning: min_mul_mul_right -> min_mul_mul_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.min.{u1} α _inst_1 a b) c)
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.min.{u1} α _inst_1 a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.385 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.387 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.385 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.387)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.400 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.402 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.400 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.402)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) c)
 Case conversion may be inaccurate. Consider using '#align min_mul_mul_right min_mul_mul_rightₓ'. -/
@@ -107,7 +107,7 @@ theorem min_mul_mul_right (a b c : α) : min (a * c) (b * c) = min a b * c :=
 
 /- warning: max_mul_mul_right -> max_mul_mul_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.max.{u1} α _inst_1 a b) c)
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.max.{u1} α _inst_1 a b) c)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.464 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.466 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.464 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.466)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.479 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.481 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.479 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.481)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) c)
 Case conversion may be inaccurate. Consider using '#align max_mul_mul_right max_mul_mul_rightₓ'. -/
@@ -119,7 +119,12 @@ theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
 
 end Right
 
-#print lt_or_lt_of_mul_lt_mul /-
+/- warning: lt_or_lt_of_mul_lt_mul -> lt_or_lt_of_mul_lt_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.541 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.543 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.541 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.543) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.556 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.558 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.556 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.558)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.578 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.580 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.578 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.580)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.593 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.595 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.593 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.595)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
+Case conversion may be inaccurate. Consider using '#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mulₓ'. -/
 @[to_additive]
 theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -129,9 +134,13 @@ theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
   exact fun h => mul_le_mul' h.1 h.2
 #align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
 #align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
--/
 
-#print le_or_lt_of_mul_le_mul /-
+/- warning: le_or_lt_of_mul_le_mul -> le_or_lt_of_mul_le_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.672 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.674 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.672 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.674) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.687 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.689 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.687 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.689)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.709 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.711 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.709 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.711)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.724 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.726 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.724 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.726)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
+Case conversion may be inaccurate. Consider using '#align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mulₓ'. -/
 @[to_additive]
 theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -141,9 +150,13 @@ theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
   exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
 #align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mul
 #align le_or_lt_of_add_le_add le_or_lt_of_add_le_add
--/
 
-#print lt_or_le_of_mul_le_mul /-
+/- warning: lt_or_le_of_mul_le_mul -> lt_or_le_of_mul_le_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.803 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.805 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.803 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.805) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.818 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.820 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.818 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.820)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.840 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.842 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.840 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.842)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.855 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.857 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.855 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.857)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
+Case conversion may be inaccurate. Consider using '#align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mulₓ'. -/
 @[to_additive]
 theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -153,9 +166,13 @@ theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
   exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
 #align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mul
 #align lt_or_le_of_add_le_add lt_or_le_of_add_le_add
--/
 
-#print le_or_le_of_mul_le_mul /-
+/- warning: le_or_le_of_mul_le_mul -> le_or_le_of_mul_le_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.934 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.936 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.934 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.936) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.949 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.951 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.949 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.951)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.971 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.973 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.971 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.973)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.986 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.988 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.986 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.988)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂))
+Case conversion may be inaccurate. Consider using '#align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mulₓ'. -/
 @[to_additive]
 theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -165,9 +182,13 @@ theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
   exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
 #align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mul
 #align le_or_le_of_add_le_add le_or_le_of_add_le_add
--/
 
-#print mul_lt_mul_iff_of_le_of_le /-
+/- warning: mul_lt_mul_iff_of_le_of_le -> mul_lt_mul_iff_of_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_5 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) (Or (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1065 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1067 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1065 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1067) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1080 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1082 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1080 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1082)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1102 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1104 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1102 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1104)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1117 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1119 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1117 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1119)] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1136 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1138 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1136 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1138) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1151 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1153 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1151 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1153)] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1173 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1175 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1173 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1175)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1188 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1190 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1188 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1190)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ b₂)))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_leₓ'. -/
 @[to_additive]
 theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [CovariantClass α α (· * ·) (· < ·)]
@@ -180,7 +201,6 @@ theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
   · exact mul_lt_mul_of_le_of_lt ha hb
 #align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
 #align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
--/
 
 end Mul
 
@@ -188,7 +208,7 @@ variable [MulOneClass α]
 
 /- warning: min_le_mul_of_one_le_right -> min_le_mul_of_one_le_right is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1296 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1298 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1296 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1298) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1311 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1313 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1311 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1313)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
 Case conversion may be inaccurate. Consider using '#align min_le_mul_of_one_le_right min_le_mul_of_one_le_rightₓ'. -/
@@ -201,7 +221,7 @@ theorem min_le_mul_of_one_le_right [CovariantClass α α (· * ·) (· ≤ ·)]
 
 /- warning: min_le_mul_of_one_le_left -> min_le_mul_of_one_le_left is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1368 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1370 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1368 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1370)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1383 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1385 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1383 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1385)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
 Case conversion may be inaccurate. Consider using '#align min_le_mul_of_one_le_left min_le_mul_of_one_le_leftₓ'. -/
@@ -214,7 +234,7 @@ theorem min_le_mul_of_one_le_left [CovariantClass α α (Function.swap (· * ·)
 
 /- warning: max_le_mul_of_one_le -> max_le_mul_of_one_le is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.max.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.max.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1437 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1439 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1437 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1439) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1452 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1454 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1452 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1454)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1474 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1476 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1474 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1476)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1489 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1491 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1489 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1491)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
 Case conversion may be inaccurate. Consider using '#align max_le_mul_of_one_le max_le_mul_of_one_leₓ'. -/

de87d505

bump to nightly-2023-03-29-08

mathlib commit https://github.com/leanprover-community/mathlib/commit/0148d455199ed64bf8eb2f493a1e7eb9211ce170

fbc8cdc2

Diff

@@ -67,7 +67,7 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.min.{u1} α _inst_1 b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.180 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.182 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.180 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.182) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.195 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.197 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.195 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.197)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) b c))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.181 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.183 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.181 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.183) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.196 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.198 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.196 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.198)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) b c))
 Case conversion may be inaccurate. Consider using '#align min_mul_mul_left min_mul_mul_leftₓ'. -/
 @[to_additive]
 theorem min_mul_mul_left (a b c : α) : min (a * b) (a * c) = a * min b c :=
@@ -79,7 +79,7 @@ theorem min_mul_mul_left (a b c : α) : min (a * b) (a * c) = a * min b c :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (LinearOrder.max.{u1} α _inst_1 b c))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.256 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.258 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.256 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.258) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.271 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.273 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.271 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.273)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) b c))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.257 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.259 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.257 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.259) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.272 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.274 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.272 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.274)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) b c))
 Case conversion may be inaccurate. Consider using '#align max_mul_mul_left max_mul_mul_leftₓ'. -/
 @[to_additive]
 theorem max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c :=
@@ -97,7 +97,7 @@ variable [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.min.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.min.{u1} α _inst_1 a b) c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.737 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.739 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.737 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.739)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.752 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.754 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.752 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.754)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.385 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.387 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.385 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.387)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.400 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.402 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.400 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.402)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) c)
 Case conversion may be inaccurate. Consider using '#align min_mul_mul_right min_mul_mul_rightₓ'. -/
 @[to_additive]
 theorem min_mul_mul_right (a b c : α) : min (a * c) (b * c) = min a b * c :=
@@ -109,7 +109,7 @@ theorem min_mul_mul_right (a b c : α) : min (a * c) (b * c) = min a b * c :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] (a : α) (b : α) (c : α), Eq.{succ u1} α (LinearOrder.max.{u1} α _inst_1 (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (LinearOrder.max.{u1} α _inst_1 a b) c)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.816 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.818 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.816 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.818)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.831 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.833 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.831 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.833)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) c)
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.464 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.466 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.464 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.466)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.479 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.481 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.479 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.481)] (a : α) (b : α) (c : α), Eq.{succ u1} α (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a c) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b c)) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) c)
 Case conversion may be inaccurate. Consider using '#align max_mul_mul_right max_mul_mul_rightₓ'. -/
 @[to_additive]
 theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
@@ -119,12 +119,7 @@ theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
 
 end Right
 
-/- warning: lt_or_lt_of_mul_lt_mul -> lt_or_lt_of_mul_lt_mul is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.332 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.334 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.332 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.334) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.347 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.349 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.347 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.349)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.369 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.371 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.369 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.371)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.384 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.386 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.384 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.386)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b₁ b₂) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ a₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ a₁) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₂ a₂))
-Case conversion may be inaccurate. Consider using '#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mulₓ'. -/
+#print lt_or_lt_of_mul_lt_mul /-
 @[to_additive]
 theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -134,7 +129,9 @@ theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
   exact fun h => mul_le_mul' h.1 h.2
 #align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
 #align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
+-/
 
+#print le_or_lt_of_mul_le_mul /-
 @[to_additive]
 theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -144,7 +141,9 @@ theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
   exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
 #align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mul
 #align le_or_lt_of_add_le_add le_or_lt_of_add_le_add
+-/
 
+#print lt_or_le_of_mul_le_mul /-
 @[to_additive]
 theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -154,7 +153,9 @@ theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
   exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
 #align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mul
 #align lt_or_le_of_add_le_add lt_or_le_of_add_le_add
+-/
 
+#print le_or_le_of_mul_le_mul /-
 @[to_additive]
 theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
     [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
@@ -164,13 +165,9 @@ theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
   exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
 #align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mul
 #align le_or_le_of_add_le_add le_or_le_of_add_le_add
+-/
 
-/- warning: mul_lt_mul_iff_of_le_of_le -> mul_lt_mul_iff_of_le_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_5 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.465 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.467 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.465 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.467) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.480 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.482 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.480 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.482)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.502 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.504 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.502 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.504)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.517 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.519 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.517 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.519)] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.536 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.538 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.536 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.538) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.551 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.553 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.551 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.553)] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.573 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.575 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.573 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.575)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.588 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.590 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.588 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.590)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ b₁) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₂ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ a₂) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b₁ b₂)) (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ b₁) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₂ b₂)))
-Case conversion may be inaccurate. Consider using '#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_leₓ'. -/
+#print mul_lt_mul_iff_of_le_of_le /-
 @[to_additive]
 theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
     [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [CovariantClass α α (· * ·) (· < ·)]
@@ -183,6 +180,7 @@ theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
   · exact mul_lt_mul_of_le_of_lt ha hb
 #align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
 #align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
+-/
 
 end Mul
 
@@ -192,7 +190,7 @@ variable [MulOneClass α]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.904 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.906 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.904 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.906) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.919 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.921 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.919 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.921)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1296 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1298 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1296 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1298) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1311 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1313 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1311 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1313)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
 Case conversion may be inaccurate. Consider using '#align min_le_mul_of_one_le_right min_le_mul_of_one_le_rightₓ'. -/
 @[to_additive]
 theorem min_le_mul_of_one_le_right [CovariantClass α α (· * ·) (· ≤ ·)] {a b : α} (hb : 1 ≤ b) :
@@ -205,7 +203,7 @@ theorem min_le_mul_of_one_le_right [CovariantClass α α (· * ·) (· ≤ ·)]
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.min.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.976 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.978 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.976 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.978)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.991 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.993 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.991 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.993)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1368 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1370 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1368 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1370)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1383 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1385 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1383 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1385)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Min.min.{u1} α (LinearOrder.toMin.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
 Case conversion may be inaccurate. Consider using '#align min_le_mul_of_one_le_left min_le_mul_of_one_le_leftₓ'. -/
 @[to_additive]
 theorem min_le_mul_of_one_le_left [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b : α}
@@ -218,7 +216,7 @@ theorem min_le_mul_of_one_le_left [CovariantClass α α (Function.swap (· * ·)
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (OfNat.ofNat.{u1} α 1 (OfNat.mk.{u1} α 1 (One.one.{u1} α (MulOneClass.toHasOne.{u1} α _inst_2)))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (LinearOrder.max.{u1} α _inst_1 a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toHasMul.{u1} α _inst_2)) a b))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1045 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1047 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1045 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1047) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1060 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1062 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1060 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1062)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1082 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1084 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1082 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1084)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1097 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1099 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1097 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1099)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : MulOneClass.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1437 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1439 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1437 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1439) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1452 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1454 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1452 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1454)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1474 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1476 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1474 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1476)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1489 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1491 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1489 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.1491)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (OfNat.ofNat.{u1} α 1 (One.toOfNat1.{u1} α (MulOneClass.toOne.{u1} α _inst_2))) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (Max.max.{u1} α (LinearOrder.toMax.{u1} α _inst_1) a b) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α (MulOneClass.toMul.{u1} α _inst_2)) a b))
 Case conversion may be inaccurate. Consider using '#align max_le_mul_of_one_le max_le_mul_of_one_leₓ'. -/
 @[to_additive]
 theorem max_le_mul_of_one_le [CovariantClass α α (· * ·) (· ≤ ·)]

de87d505

bump to nightly-2023-03-29-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/0148d455199ed64bf8eb2f493a1e7eb9211ce170

5cbaeba8

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.min_max
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
+! leanprover-community/mathlib commit de87d5053a9fe5cbde723172c0fb7e27e7436473
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -19,6 +19,8 @@ import Mathbin.Algebra.Order.Monoid.Lemmas
 -/
 
 
+open Function
+
 variable {α β : Type _}
 
 /-! Some lemmas about types that have an ordering and a binary operation, with no
@@ -85,30 +87,6 @@ theorem max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c :=
 #align max_mul_mul_left max_mul_mul_left
 #align max_add_add_left max_add_add_left
 
-#print lt_or_lt_of_mul_lt_mul /-
-@[to_additive]
-theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b m n : α}
-    (h : m * n < a * b) : m < a ∨ n < b := by
-  contrapose! h
-  exact mul_le_mul' h.1 h.2
-#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
-#align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
--/
-
-#print mul_lt_mul_iff_of_le_of_le /-
-@[to_additive]
-theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (Function.swap (· * ·)) (· < ·)]
-    [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)]
-    {a b c d : α} (ac : a ≤ c) (bd : b ≤ d) : a * b < c * d ↔ a < c ∨ b < d :=
-  by
-  refine' ⟨lt_or_lt_of_mul_lt_mul, fun h => _⟩
-  cases' h with ha hb
-  · exact mul_lt_mul_of_lt_of_le ha bd
-  · exact mul_lt_mul_of_le_of_lt ac hb
-#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
-#align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
--/
-
 end Left
 
 section Right
@@ -141,6 +119,71 @@ theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
 
 end Right
 
+/- warning: lt_or_lt_of_mul_lt_mul -> lt_or_lt_of_mul_lt_mul is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.332 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.334 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.332 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.334) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.347 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.349 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.347 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.349)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.369 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.371 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.369 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.371)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.384 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.386 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.384 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.386)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b₁ b₂) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ a₂)) -> (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₁ a₁) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) b₂ a₂))
+Case conversion may be inaccurate. Consider using '#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mulₓ'. -/
+@[to_additive]
+theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
+    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ :=
+  by
+  contrapose!
+  exact fun h => mul_le_mul' h.1 h.2
+#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
+#align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
+
+@[to_additive]
+theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
+    [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ :=
+  by
+  contrapose!
+  exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
+#align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mul
+#align le_or_lt_of_add_le_add le_or_lt_of_add_le_add
+
+@[to_additive]
+theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
+    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂ :=
+  by
+  contrapose!
+  exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
+#align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mul
+#align lt_or_le_of_add_le_add lt_or_le_of_add_le_add
+
+@[to_additive]
+theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
+    [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂ :=
+  by
+  contrapose!
+  exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
+#align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mul
+#align le_or_le_of_add_le_add le_or_le_of_add_le_add
+
+/- warning: mul_lt_mul_iff_of_le_of_le -> mul_lt_mul_iff_of_le_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_5 : CovariantClass.{u1, u1} α α (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2))) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ b₁) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₂ b₂)) (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a₁ a₂) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) b₁ b₂)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Mul.{u1} α] [_inst_3 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.465 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.467 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.465 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.467) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.480 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.482 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.480 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.482)] [_inst_4 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.502 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.504 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.502 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.504)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.517 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.519 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.517 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.519)] [_inst_5 : CovariantClass.{u1, u1} α α (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.536 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.538 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.536 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.538) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.551 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.553 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.551 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.553)] [_inst_6 : CovariantClass.{u1, u1} α α (Function.swap.{succ u1, succ u1, succ u1} α α (fun (ᾰ : α) (ᾰ : α) => α) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.573 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.575 : α) => HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.573 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.575)) (fun (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.588 : α) (x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.590 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.588 x._@.Mathlib.Algebra.Order.Monoid.MinMax._hyg.590)] {a₁ : α} {a₂ : α} {b₁ : α} {b₂ : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ b₁) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₂ b₂) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) a₁ a₂) (HMul.hMul.{u1, u1, u1} α α α (instHMul.{u1} α _inst_2) b₁ b₂)) (Or (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₁ b₁) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a₂ b₂)))
+Case conversion may be inaccurate. Consider using '#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_leₓ'. -/
+@[to_additive]
+theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
+    [CovariantClass α α (swap (· * ·)) (· ≤ ·)] [CovariantClass α α (· * ·) (· < ·)]
+    [CovariantClass α α (swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} (ha : a₁ ≤ a₂) (hb : b₁ ≤ b₂) :
+    a₁ * b₁ < a₂ * b₂ ↔ a₁ < a₂ ∨ b₁ < b₂ :=
+  by
+  refine' ⟨lt_or_lt_of_mul_lt_mul, _⟩
+  rintro (ha | hb)
+  · exact mul_lt_mul_of_lt_of_le ha hb
+  · exact mul_lt_mul_of_le_of_lt ha hb
+#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
+#align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
+
 end Mul
 
 variable [MulOneClass α]

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

de87d505

chore: tidy various files (#11624)

483848e8

Diff

@@ -21,7 +21,7 @@ variable {α β : Type*}
   rules relating them. -/
 
 section CommSemigroup
-variable[LinearOrder α] [CommSemigroup α] [CommSemigroup β]
+variable [LinearOrder α] [CommSemigroup α] [CommSemigroup β]
 
 @[to_additive]
 lemma fn_min_mul_fn_max  (f : α → β) (a b : α) : f (min a b) * f (max a b) = f a * f b := by

de87d505

chore: Generalise monotonicity of multiplication lemmas to semirings (#9369)

Many lemmas about BlahOrderedRing α did not mention negation. I could generalise almost all those lemmas to BlahOrderedSemiring α + ExistsAddOfLE α except for a series of five lemmas (left a TODO about them).

Now those lemmas apply to things like the naturals. This is not very useful on its own, because those lemmas are trivially true on canonically ordered semirings (they are about multiplication by negative elements, of which there are none, or nonnegativity of squares, but we already know everything is nonnegative), except that I will soon add more complicated inequalities that are based on those, and it would be a shame having to write two versions of each: one for ordered rings, one for canonically ordered semirings.

A similar refactor could be made for scalar multiplication, but this PR is big enough already.

From LeanAPAP

0c9d4118

Diff

@@ -20,20 +20,29 @@ variable {α β : Type*}
 /-! Some lemmas about types that have an ordering and a binary operation, with no
   rules relating them. -/
 
+section CommSemigroup
+variable[LinearOrder α] [CommSemigroup α] [CommSemigroup β]
 
 @[to_additive]
-theorem fn_min_mul_fn_max [LinearOrder α] [CommSemigroup β] (f : α → β) (n m : α) :
-    f (min n m) * f (max n m) = f n * f m := by
-  rcases le_total n m with h | h <;> simp [h, mul_comm]
+lemma fn_min_mul_fn_max  (f : α → β) (a b : α) : f (min a b) * f (max a b) = f a * f b := by
+  obtain h | h := le_total a b <;> simp [h, mul_comm]
 #align fn_min_mul_fn_max fn_min_mul_fn_max
 #align fn_min_add_fn_max fn_min_add_fn_max
 
 @[to_additive]
-theorem min_mul_max [LinearOrder α] [CommSemigroup α] (n m : α) : min n m * max n m = n * m :=
-  fn_min_mul_fn_max id n m
+lemma fn_max_mul_fn_min (f : α → β) (a b : α) : f (max a b) * f (min a b) = f a * f b := by
+  obtain h | h := le_total a b <;> simp [h, mul_comm]
+
+@[to_additive (attr := simp)]
+lemma min_mul_max (a b : α) : min a b * max a b = a * b := fn_min_mul_fn_max id _ _
 #align min_mul_max min_mul_max
 #align min_add_max min_add_max
 
+@[to_additive (attr := simp)]
+lemma max_mul_min (a b : α) : max a b * min a b = a * b := fn_max_mul_fn_min id _ _
+
+end CommSemigroup
+
 section CovariantClassMulLe
 
 variable [LinearOrder α]

de87d505

chore: remove uses of cases' (#9171)

I literally went through and regex'd some uses of cases', replacing them with rcases; this is meant to be a low effort PR as I hope that tools can do this in the future.

rcases is an easier replacement than cases, though with better tools we could in future do a second pass converting simple rcases added here (and existing ones) to cases.

3fca282c

Diff

@@ -23,7 +23,8 @@ variable {α β : Type*}
 
 @[to_additive]
 theorem fn_min_mul_fn_max [LinearOrder α] [CommSemigroup β] (f : α → β) (n m : α) :
-    f (min n m) * f (max n m) = f n * f m := by cases' le_total n m with h h <;> simp [h, mul_comm]
+    f (min n m) * f (max n m) = f n * f m := by
+  rcases le_total n m with h | h <;> simp [h, mul_comm]
 #align fn_min_mul_fn_max fn_min_mul_fn_max
 #align fn_min_add_fn_max fn_min_add_fn_max

de87d505

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

@@ -15,7 +15,7 @@ import Mathlib.Algebra.Order.Monoid.Lemmas
 
 open Function
 
-variable {α β : Type _}
+variable {α β : Type*}
 
 /-! Some lemmas about types that have an ordering and a binary operation, with no
   rules relating them. -/

de87d505

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) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
-
-! This file was ported from Lean 3 source module algebra.order.monoid.min_max
-! leanprover-community/mathlib commit de87d5053a9fe5cbde723172c0fb7e27e7436473
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.MinMax
 import Mathlib.Algebra.Order.Monoid.Lemmas
 
+#align_import algebra.order.monoid.min_max from "leanprover-community/mathlib"@"de87d5053a9fe5cbde723172c0fb7e27e7436473"
+
 /-!
 # Lemmas about `min` and `max` in an ordered monoid.
 -/

de87d505

feat: add Mathlib.Tactic.Common, and import (#4056)

This makes a mathlib4 version of mathlib3's tactic.basic, now called Mathlib.Tactic.Common, which imports all tactics which do not have significant theory requirements, and then is imported all across the base of the hierarchy.

This ensures that all common tactics are available nearly everywhere in the library, rather than having to be imported one-by-one as you need them.

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

a4eaf1c4

Diff

@@ -10,7 +10,6 @@ Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 -/
 import Mathlib.Order.MinMax
 import Mathlib.Algebra.Order.Monoid.Lemmas
-import Mathlib.Tactic.Contrapose
 
 /-!
 # Lemmas about `min` and `max` in an ordered monoid.

de87d505

chore: forward port leanprover-community/mathlib#18667 (#3163)

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

1e9f59dd

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
 
 ! This file was ported from Lean 3 source module algebra.order.monoid.min_max
-! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! leanprover-community/mathlib commit de87d5053a9fe5cbde723172c0fb7e27e7436473
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -17,6 +17,8 @@ import Mathlib.Tactic.Contrapose
 -/
 
 
+open Function
+
 variable {α β : Type _}
 
 /-! Some lemmas about types that have an ordering and a binary operation, with no
@@ -59,25 +61,6 @@ theorem max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c :=
 #align max_mul_mul_left max_mul_mul_left
 #align max_add_add_left max_add_add_left
 
-@[to_additive]
-theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b m n : α}
-    (h : m * n < a * b) : m < a ∨ n < b := by
-  contrapose! h
-  exact mul_le_mul' h.1 h.2
-#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
-#align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
-
-@[to_additive]
-theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (Function.swap (· * ·)) (· < ·)]
-    [CovariantClass α α (· * ·) (· < ·)] [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)]
-    {a b c d : α} (ac : a ≤ c) (bd : b ≤ d) : a * b < c * d ↔ a < c ∨ b < d := by
-  refine' ⟨lt_or_lt_of_mul_lt_mul, fun h => _⟩
-  cases' h with ha hb
-  · exact mul_lt_mul_of_lt_of_le ha bd
-  · exact mul_lt_mul_of_le_of_lt ac hb
-#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
-#align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
-
 end Left
 
 section Right
@@ -98,6 +81,54 @@ theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
 
 end Right
 
+@[to_additive]
+theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
+    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ := by
+  contrapose!
+  exact fun h => mul_le_mul' h.1 h.2
+#align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
+#align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
+
+@[to_additive]
+theorem le_or_lt_of_mul_le_mul [CovariantClass α α (· * ·) (· ≤ ·)]
+    [CovariantClass α α (Function.swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ < b₂ := by
+  contrapose!
+  exact fun h => mul_lt_mul_of_lt_of_le h.1 h.2
+#align le_or_lt_of_mul_le_mul le_or_lt_of_mul_le_mul
+#align le_or_lt_of_add_le_add le_or_lt_of_add_le_add
+
+@[to_additive]
+theorem lt_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
+    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ < a₂ ∨ b₁ ≤ b₂ := by
+  contrapose!
+  exact fun h => mul_lt_mul_of_le_of_lt h.1 h.2
+#align lt_or_le_of_mul_le_mul lt_or_le_of_mul_le_mul
+#align lt_or_le_of_add_le_add lt_or_le_of_add_le_add
+
+@[to_additive]
+theorem le_or_le_of_mul_le_mul [CovariantClass α α (· * ·) (· < ·)]
+    [CovariantClass α α (Function.swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} :
+    a₁ * b₁ ≤ a₂ * b₂ → a₁ ≤ a₂ ∨ b₁ ≤ b₂ := by
+  contrapose!
+  exact fun h => mul_lt_mul_of_lt_of_lt h.1 h.2
+#align le_or_le_of_mul_le_mul le_or_le_of_mul_le_mul
+#align le_or_le_of_add_le_add le_or_le_of_add_le_add
+
+@[to_additive]
+theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (· * ·) (· ≤ ·)]
+    [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] [CovariantClass α α (· * ·) (· < ·)]
+    [CovariantClass α α (Function.swap (· * ·)) (· < ·)] {a₁ a₂ b₁ b₂ : α} (ha : a₁ ≤ a₂)
+    (hb : b₁ ≤ b₂) : a₁ * b₁ < a₂ * b₂ ↔ a₁ < a₂ ∨ b₁ < b₂ := by
+  refine' ⟨lt_or_lt_of_mul_lt_mul, fun h => _⟩
+  cases' h with ha' hb'
+  · exact mul_lt_mul_of_lt_of_le ha' hb
+  · exact mul_lt_mul_of_le_of_lt ha hb'
+#align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
+#align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
+
 end Mul
 
 variable [MulOneClass α]

70d50ecf

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

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

ed378238

Diff

@@ -27,11 +27,13 @@ variable {α β : Type _}
 theorem fn_min_mul_fn_max [LinearOrder α] [CommSemigroup β] (f : α → β) (n m : α) :
     f (min n m) * f (max n m) = f n * f m := by cases' le_total n m with h h <;> simp [h, mul_comm]
 #align fn_min_mul_fn_max fn_min_mul_fn_max
+#align fn_min_add_fn_max fn_min_add_fn_max
 
 @[to_additive]
 theorem min_mul_max [LinearOrder α] [CommSemigroup α] (n m : α) : min n m * max n m = n * m :=
   fn_min_mul_fn_max id n m
 #align min_mul_max min_mul_max
+#align min_add_max min_add_max
 
 section CovariantClassMulLe
 
@@ -49,11 +51,13 @@ variable [CovariantClass α α (· * ·) (· ≤ ·)]
 theorem min_mul_mul_left (a b c : α) : min (a * b) (a * c) = a * min b c :=
   (monotone_id.const_mul' a).map_min.symm
 #align min_mul_mul_left min_mul_mul_left
+#align min_add_add_left min_add_add_left
 
 @[to_additive]
 theorem max_mul_mul_left (a b c : α) : max (a * b) (a * c) = a * max b c :=
   (monotone_id.const_mul' a).map_max.symm
 #align max_mul_mul_left max_mul_mul_left
+#align max_add_add_left max_add_add_left
 
 @[to_additive]
 theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b m n : α}
@@ -61,6 +65,7 @@ theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (Function.swap (· * ·)) (
   contrapose! h
   exact mul_le_mul' h.1 h.2
 #align lt_or_lt_of_mul_lt_mul lt_or_lt_of_mul_lt_mul
+#align lt_or_lt_of_add_lt_add lt_or_lt_of_add_lt_add
 
 @[to_additive]
 theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (Function.swap (· * ·)) (· < ·)]
@@ -71,6 +76,7 @@ theorem mul_lt_mul_iff_of_le_of_le [CovariantClass α α (Function.swap (· * ·
   · exact mul_lt_mul_of_lt_of_le ha bd
   · exact mul_lt_mul_of_le_of_lt ac hb
 #align mul_lt_mul_iff_of_le_of_le mul_lt_mul_iff_of_le_of_le
+#align add_lt_add_iff_of_le_of_le add_lt_add_iff_of_le_of_le
 
 end Left
 
@@ -82,11 +88,13 @@ variable [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)]
 theorem min_mul_mul_right (a b c : α) : min (a * c) (b * c) = min a b * c :=
   (monotone_id.mul_const' c).map_min.symm
 #align min_mul_mul_right min_mul_mul_right
+#align min_add_add_right min_add_add_right
 
 @[to_additive]
 theorem max_mul_mul_right (a b c : α) : max (a * c) (b * c) = max a b * c :=
   (monotone_id.mul_const' c).map_max.symm
 #align max_mul_mul_right max_mul_mul_right
+#align max_add_add_right max_add_add_right
 
 end Right
 
@@ -99,12 +107,14 @@ theorem min_le_mul_of_one_le_right [CovariantClass α α (· * ·) (· ≤ ·)]
     min a b ≤ a * b :=
   min_le_iff.2 <| Or.inl <| le_mul_of_one_le_right' hb
 #align min_le_mul_of_one_le_right min_le_mul_of_one_le_right
+#align min_le_add_of_nonneg_right min_le_add_of_nonneg_right
 
 @[to_additive]
 theorem min_le_mul_of_one_le_left [CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a b : α}
     (ha : 1 ≤ a) : min a b ≤ a * b :=
   min_le_iff.2 <| Or.inr <| le_mul_of_one_le_left' ha
 #align min_le_mul_of_one_le_left min_le_mul_of_one_le_left
+#align min_le_add_of_nonneg_left min_le_add_of_nonneg_left
 
 @[to_additive]
 theorem max_le_mul_of_one_le [CovariantClass α α (· * ·) (· ≤ ·)]
@@ -112,5 +122,6 @@ theorem max_le_mul_of_one_le [CovariantClass α α (· * ·) (· ≤ ·)]
     max a b ≤ a * b :=
   max_le_iff.2 ⟨le_mul_of_one_le_right' hb, le_mul_of_one_le_left' ha⟩
 #align max_le_mul_of_one_le max_le_mul_of_one_le
+#align max_le_add_of_nonneg max_le_add_of_nonneg
 
 end CovariantClassMulLe

70d50ecf

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) 2016 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Leonardo de Moura, Mario Carneiro, Johannes Hölzl
+
+! This file was ported from Lean 3 source module algebra.order.monoid.min_max
+! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Order.MinMax
 import Mathlib.Algebra.Order.Monoid.Lemmas

`algebra.order.monoid.min_max` ⟷ `Mathlib.Algebra.Order.Monoid.MinMax`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 25

algebra.order.monoid.min_max ⟷ Mathlib.Algebra.Order.Monoid.MinMax

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 25

`algebra.order.monoid.min_max` ⟷ `Mathlib.Algebra.Order.Monoid.MinMax`