order.compare | 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

c4658a64

(last sync)

Changes in mathlib3port

mathlib3

mathlib3port

448144f7

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -157,12 +157,12 @@ theorem compares_iff_of_compares_impl {β : Type _} [LinearOrder α] [Preorder 
   by
   refine' ⟨h, fun ho => _⟩
   cases' lt_trichotomy a b with hab hab
-  · change compares Ordering.lt a b at hab 
+  · change compares Ordering.lt a b at hab
     rwa [ho.inj (h hab)]
   · cases' hab with hab hab
-    · change compares Ordering.eq a b at hab 
+    · change compares Ordering.eq a b at hab
       rwa [ho.inj (h hab)]
-    · change compares Ordering.gt a b at hab 
+    · change compares Ordering.gt a b at hab
       rwa [ho.inj (h hab)]
 #align ordering.compares_iff_of_compares_impl Ordering.compares_iff_of_compares_impl
 -/

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
 -/
-import Mathbin.Order.Synonym
+import Order.Synonym
 
 #align_import order.compare from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

448144f7

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -72,7 +72,7 @@ theorem compares_swap [LT α] {a b : α} {o : Ordering} : o.symm.Compares a b 
 #align ordering.compares_swap Ordering.compares_swap
 -/
 
-alias compares_swap ↔ compares.of_swap compares.swap
+alias ⟨compares.of_swap, compares.swap⟩ := compares_swap
 #align ordering.compares.of_swap Ordering.Compares.of_swap
 #align ordering.compares.swap Ordering.Compares.swap

448144f7

bump to nightly-2023-07-20-09

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

9c56d0dd

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module order.compare
-! leanprover-community/mathlib commit 448144f7ae193a8990cb7473c9e9a01990f64ac7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Synonym
 
+#align_import order.compare from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Comparison

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -153,6 +153,7 @@ theorem Compares.inj [Preorder α] {o₁} :
 #align ordering.compares.inj Ordering.Compares.inj
 -/
 
+#print Ordering.compares_iff_of_compares_impl /-
 theorem compares_iff_of_compares_impl {β : Type _} [LinearOrder α] [Preorder β] {a b : α}
     {a' b' : β} (h : ∀ {o}, Compares o a b → Compares o a' b') (o) :
     Compares o a b ↔ Compares o a' b' :=
@@ -167,6 +168,7 @@ theorem compares_iff_of_compares_impl {β : Type _} [LinearOrder α] [Preorder 
     · change compares Ordering.gt a b at hab 
       rwa [ho.inj (h hab)]
 #align ordering.compares_iff_of_compares_impl Ordering.compares_iff_of_compares_impl
+-/
 
 #print Ordering.swap_orElse /-
 theorem swap_orElse (o₁ o₂) : (orElse o₁ o₂).symm = orElse o₁.symm o₂.symm := by
@@ -241,19 +243,23 @@ theorem cmpLE_ofDual [LE α] [@DecidableRel α (· ≤ ·)] (x y : αᵒᵈ) :
 
 /- warning: cmp_to_dual clashes with cmp_le_to_dual -> cmpLE_toDual
 Case conversion may be inaccurate. Consider using '#align cmp_to_dual cmpLE_toDualₓ'. -/
+#print cmpLE_toDual /-
 @[simp]
 theorem cmpLE_toDual [LT α] [@DecidableRel α (· < ·)] (x y : α) :
     cmp (toDual x) (toDual y) = cmp y x :=
   rfl
 #align cmp_to_dual cmpLE_toDual
+-/
 
 /- warning: cmp_of_dual clashes with cmp_le_of_dual -> cmpLE_ofDual
 Case conversion may be inaccurate. Consider using '#align cmp_of_dual cmpLE_ofDualₓ'. -/
+#print cmpLE_ofDual /-
 @[simp]
 theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :
     cmp (ofDual x) (ofDual y) = cmp y x :=
   rfl
 #align cmp_of_dual cmpLE_ofDual
+-/
 
 #print linearOrderOfCompares /-
 /-- Generate a linear order structure from a preorder and `cmp` function. -/
@@ -299,24 +305,32 @@ theorem cmp_self_eq_eq : cmp x x = Ordering.eq := by rw [cmp_eq_eq_iff]
 
 variable {x y} {β : Type _} [LinearOrder β] {x' y' : β}
 
+#print cmp_eq_cmp_symm /-
 theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x' := by
   rw [← cmp_swap x', ← cmp_swap x, swap_inj]
 #align cmp_eq_cmp_symm cmp_eq_cmp_symm
+-/
 
+#print lt_iff_lt_of_cmp_eq_cmp /-
 theorem lt_iff_lt_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x < y ↔ x' < y' := by
   rw [← cmp_eq_lt_iff, ← cmp_eq_lt_iff, h]
 #align lt_iff_lt_of_cmp_eq_cmp lt_iff_lt_of_cmp_eq_cmp
+-/
 
+#print le_iff_le_of_cmp_eq_cmp /-
 theorem le_iff_le_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x ≤ y ↔ x' ≤ y' :=
   by
   rw [← not_lt, ← not_lt]; apply not_congr
   apply lt_iff_lt_of_cmp_eq_cmp; rwa [cmp_eq_cmp_symm]
 #align le_iff_le_of_cmp_eq_cmp le_iff_le_of_cmp_eq_cmp
+-/
 
+#print eq_iff_eq_of_cmp_eq_cmp /-
 theorem eq_iff_eq_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x = y ↔ x' = y' := by
   rw [le_antisymm_iff, le_antisymm_iff, le_iff_le_of_cmp_eq_cmp h,
     le_iff_le_of_cmp_eq_cmp (cmp_eq_cmp_symm.1 h)]
 #align eq_iff_eq_of_cmp_eq_cmp eq_iff_eq_of_cmp_eq_cmp
+-/
 
 #print LT.lt.cmp_eq_lt /-
 theorem LT.lt.cmp_eq_lt (h : x < y) : cmp x y = Ordering.lt :=

448144f7

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -71,7 +71,7 @@ def Compares [LT α] : Ordering → α → α → Prop
 
 #print Ordering.compares_swap /-
 theorem compares_swap [LT α] {a b : α} {o : Ordering} : o.symm.Compares a b ↔ o.Compares b a := by
-  cases o; exacts[Iff.rfl, eq_comm, Iff.rfl]
+  cases o; exacts [Iff.rfl, eq_comm, Iff.rfl]
 #align ordering.compares_swap Ordering.compares_swap
 -/
 
@@ -159,12 +159,12 @@ theorem compares_iff_of_compares_impl {β : Type _} [LinearOrder α] [Preorder 
   by
   refine' ⟨h, fun ho => _⟩
   cases' lt_trichotomy a b with hab hab
-  · change compares Ordering.lt a b at hab
+  · change compares Ordering.lt a b at hab 
     rwa [ho.inj (h hab)]
   · cases' hab with hab hab
-    · change compares Ordering.eq a b at hab
+    · change compares Ordering.eq a b at hab 
       rwa [ho.inj (h hab)]
-    · change compares Ordering.gt a b at hab
+    · change compares Ordering.gt a b at hab 
       rwa [ho.inj (h hab)]
 #align ordering.compares_iff_of_compares_impl Ordering.compares_iff_of_compares_impl
 
@@ -188,7 +188,7 @@ open Ordering OrderDual
 @[simp]
 theorem toDual_compares_toDual [LT α] {a b : α} {o : Ordering} :
     Compares o (toDual a) (toDual b) ↔ Compares o b a := by cases o;
-  exacts[Iff.rfl, eq_comm, Iff.rfl]
+  exacts [Iff.rfl, eq_comm, Iff.rfl]
 #align to_dual_compares_to_dual toDual_compares_toDual
 -/
 
@@ -196,7 +196,7 @@ theorem toDual_compares_toDual [LT α] {a b : α} {o : Ordering} :
 @[simp]
 theorem ofDual_compares_ofDual [LT α] {a b : αᵒᵈ} {o : Ordering} :
     Compares o (ofDual a) (ofDual b) ↔ Compares o b a := by cases o;
-  exacts[Iff.rfl, eq_comm, Iff.rfl]
+  exacts [Iff.rfl, eq_comm, Iff.rfl]
 #align of_dual_compares_of_dual ofDual_compares_ofDual
 -/

448144f7

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -47,12 +47,14 @@ theorem cmpLE_swap {α} [LE α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· 
 #align cmp_le_swap cmpLE_swap
 -/
 
+#print cmpLE_eq_cmp /-
 theorem cmpLE_eq_cmp {α} [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)]
     [@DecidableRel α (· < ·)] (x y : α) : cmpLE x y = cmp x y :=
   by
   by_cases xy : x ≤ y <;> by_cases yx : y ≤ x <;> simp [cmpLE, lt_iff_le_not_le, *, cmp, cmpUsing]
   cases not_or_of_not xy yx (total_of _ _ _)
 #align cmp_le_eq_cmp cmpLE_eq_cmp
+-/
 
 namespace Ordering
 
@@ -90,50 +92,66 @@ theorem swap_eq_iff_eq_swap {o o' : Ordering} : o.symm = o' ↔ o = o'.symm := b
 #align ordering.swap_eq_iff_eq_swap Ordering.swap_eq_iff_eq_swap
 -/
 
+#print Ordering.Compares.eq_lt /-
 theorem Compares.eq_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = lt ↔ a < b)
   | lt, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | Eq, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h' h).elim⟩
   | GT.gt, a, b, h => ⟨fun h => by injection h, fun h' => (lt_asymm h h').elim⟩
 #align ordering.compares.eq_lt Ordering.Compares.eq_lt
+-/
 
+#print Ordering.Compares.ne_lt /-
 theorem Compares.ne_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o ≠ lt ↔ b ≤ a)
   | lt, a, b, h => ⟨absurd rfl, fun h' => (not_le_of_lt h h').elim⟩
   | Eq, a, b, h => ⟨fun _ => ge_of_eq h, fun _ h => by injection h⟩
   | GT.gt, a, b, h => ⟨fun _ => le_of_lt h, fun _ h => by injection h⟩
 #align ordering.compares.ne_lt Ordering.Compares.ne_lt
+-/
 
+#print Ordering.Compares.eq_eq /-
 theorem Compares.eq_eq [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = eq ↔ a = b)
   | lt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h h').elim⟩
   | Eq, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | GT.gt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_gt h h').elim⟩
 #align ordering.compares.eq_eq Ordering.Compares.eq_eq
+-/
 
+#print Ordering.Compares.eq_gt /-
 theorem Compares.eq_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o = gt ↔ b < a :=
   swap_eq_iff_eq_swap.symm.trans h.symm.eq_lt
 #align ordering.compares.eq_gt Ordering.Compares.eq_gt
+-/
 
+#print Ordering.Compares.ne_gt /-
 theorem Compares.ne_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o ≠ gt ↔ a ≤ b :=
   (not_congr swap_eq_iff_eq_swap.symm).trans h.symm.ne_lt
 #align ordering.compares.ne_gt Ordering.Compares.ne_gt
+-/
 
+#print Ordering.Compares.le_total /-
 theorem Compares.le_total [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b ∨ b ≤ a
   | lt, h => Or.inl (le_of_lt h)
   | Eq, h => Or.inl (le_of_eq h)
   | GT.gt, h => Or.inr (le_of_lt h)
 #align ordering.compares.le_total Ordering.Compares.le_total
+-/
 
+#print Ordering.Compares.le_antisymm /-
 theorem Compares.le_antisymm [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b → b ≤ a → a = b
   | lt, h, _, hba => (not_le_of_lt h hba).elim
   | Eq, h, _, _ => h
   | GT.gt, h, hab, _ => (not_le_of_lt h hab).elim
 #align ordering.compares.le_antisymm Ordering.Compares.le_antisymm
+-/
 
+#print Ordering.Compares.inj /-
 theorem Compares.inj [Preorder α] {o₁} :
     ∀ {o₂} {a b : α}, Compares o₁ a b → Compares o₂ a b → o₁ = o₂
   | lt, a, b, h₁, h₂ => h₁.eq_lt.2 h₂
   | Eq, a, b, h₁, h₂ => h₁.eq_eq.2 h₂
   | GT.gt, a, b, h₁, h₂ => h₁.eq_gt.2 h₂
 #align ordering.compares.inj Ordering.Compares.inj
+-/
 
 theorem compares_iff_of_compares_impl {β : Type _} [LinearOrder α] [Preorder β] {a b : α}
     {a' b' : β} (h : ∀ {o}, Compares o a b → Compares o a' b') (o) :
@@ -188,11 +206,14 @@ theorem cmp_compares [LinearOrder α] (a b : α) : (cmp a b).Compares a b := by
 #align cmp_compares cmp_compares
 -/
 
+#print Ordering.Compares.cmp_eq /-
 theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h : o.Compares a b) :
     cmp a b = o :=
   (cmp_compares a b).inj h
 #align ordering.compares.cmp_eq Ordering.Compares.cmp_eq
+-/
 
+#print cmp_swap /-
 @[simp]
 theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).symm = cmp b a :=
   by
@@ -200,6 +221,7 @@ theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a
   by_cases a < b <;> by_cases h₂ : b < a <;> simp [h, h₂, Ordering.swap]
   exact lt_asymm h h₂
 #align cmp_swap cmp_swap
+-/
 
 #print cmpLE_toDual /-
 @[simp]
@@ -233,6 +255,7 @@ theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :
   rfl
 #align cmp_of_dual cmpLE_ofDual
 
+#print linearOrderOfCompares /-
 /-- Generate a linear order structure from a preorder and `cmp` function. -/
 def linearOrderOfCompares [Preorder α] (cmp : α → α → Ordering)
     (h : ∀ a b, (cmp a b).Compares a b) : LinearOrder α :=
@@ -243,6 +266,7 @@ def linearOrderOfCompares [Preorder α] (cmp : α → α → Ordering)
     decidableLt := fun a b => decidable_of_iff _ (h a b).eq_lt
     DecidableEq := fun a b => decidable_of_iff _ (h a b).eq_eq }
 #align linear_order_of_compares linearOrderOfCompares
+-/
 
 variable [LinearOrder α] (x y : α)
 
@@ -294,13 +318,17 @@ theorem eq_iff_eq_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x = y ↔ x' = y' :=
     le_iff_le_of_cmp_eq_cmp (cmp_eq_cmp_symm.1 h)]
 #align eq_iff_eq_of_cmp_eq_cmp eq_iff_eq_of_cmp_eq_cmp
 
+#print LT.lt.cmp_eq_lt /-
 theorem LT.lt.cmp_eq_lt (h : x < y) : cmp x y = Ordering.lt :=
   (cmp_eq_lt_iff _ _).2 h
 #align has_lt.lt.cmp_eq_lt LT.lt.cmp_eq_lt
+-/
 
+#print LT.lt.cmp_eq_gt /-
 theorem LT.lt.cmp_eq_gt (h : x < y) : cmp y x = Ordering.gt :=
   (cmp_eq_gt_iff _ _).2 h
 #align has_lt.lt.cmp_eq_gt LT.lt.cmp_eq_gt
+-/
 
 #print Eq.cmp_eq_eq /-
 theorem Eq.cmp_eq_eq (h : x = y) : cmp x y = Ordering.eq :=

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -47,12 +47,6 @@ theorem cmpLE_swap {α} [LE α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· 
 #align cmp_le_swap cmpLE_swap
 -/
 
-/- warning: cmp_le_eq_cmp -> cmpLE_eq_cmp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))] [_inst_3 : DecidableRel.{succ u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))] [_inst_4 : DecidableRel.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_3 a b) x y) (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_4 a b) x y)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.Compare._hyg.273 : α) (x._@.Mathlib.Order.Compare._hyg.275 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.273 x._@.Mathlib.Order.Compare._hyg.275)] [_inst_3 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.291 : α) (x._@.Mathlib.Order.Compare._hyg.293 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.291 x._@.Mathlib.Order.Compare._hyg.293)] [_inst_4 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.309 : α) (x._@.Mathlib.Order.Compare._hyg.311 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.309 x._@.Mathlib.Order.Compare._hyg.311)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_3 a b) x y) (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_4 a b) x y)
-Case conversion may be inaccurate. Consider using '#align cmp_le_eq_cmp cmpLE_eq_cmpₓ'. -/
 theorem cmpLE_eq_cmp {α} [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)]
     [@DecidableRel α (· < ·)] (x y : α) : cmpLE x y = cmp x y :=
   by
@@ -96,92 +90,44 @@ theorem swap_eq_iff_eq_swap {o o' : Ordering} : o.symm = o' ↔ o = o'.symm := b
 #align ordering.swap_eq_iff_eq_swap Ordering.swap_eq_iff_eq_swap
 -/
 
-/- warning: ordering.compares.eq_lt -> Ordering.Compares.eq_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.lt) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.lt) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align ordering.compares.eq_lt Ordering.Compares.eq_ltₓ'. -/
 theorem Compares.eq_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = lt ↔ a < b)
   | lt, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | Eq, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h' h).elim⟩
   | GT.gt, a, b, h => ⟨fun h => by injection h, fun h' => (lt_asymm h h').elim⟩
 #align ordering.compares.eq_lt Ordering.Compares.eq_lt
 
-/- warning: ordering.compares.ne_lt -> Ordering.Compares.ne_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.lt) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.lt) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align ordering.compares.ne_lt Ordering.Compares.ne_ltₓ'. -/
 theorem Compares.ne_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o ≠ lt ↔ b ≤ a)
   | lt, a, b, h => ⟨absurd rfl, fun h' => (not_le_of_lt h h').elim⟩
   | Eq, a, b, h => ⟨fun _ => ge_of_eq h, fun _ h => by injection h⟩
   | GT.gt, a, b, h => ⟨fun _ => le_of_lt h, fun _ h => by injection h⟩
 #align ordering.compares.ne_lt Ordering.Compares.ne_lt
 
-/- warning: ordering.compares.eq_eq -> Ordering.Compares.eq_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.eq) (Eq.{succ u1} α a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.eq) (Eq.{succ u1} α a b))
-Case conversion may be inaccurate. Consider using '#align ordering.compares.eq_eq Ordering.Compares.eq_eqₓ'. -/
 theorem Compares.eq_eq [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = eq ↔ a = b)
   | lt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h h').elim⟩
   | Eq, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | GT.gt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_gt h h').elim⟩
 #align ordering.compares.eq_eq Ordering.Compares.eq_eq
 
-/- warning: ordering.compares.eq_gt -> Ordering.Compares.eq_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.gt) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.gt) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align ordering.compares.eq_gt Ordering.Compares.eq_gtₓ'. -/
 theorem Compares.eq_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o = gt ↔ b < a :=
   swap_eq_iff_eq_swap.symm.trans h.symm.eq_lt
 #align ordering.compares.eq_gt Ordering.Compares.eq_gt
 
-/- warning: ordering.compares.ne_gt -> Ordering.Compares.ne_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.gt) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.gt) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align ordering.compares.ne_gt Ordering.Compares.ne_gtₓ'. -/
 theorem Compares.ne_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o ≠ gt ↔ a ≤ b :=
   (not_congr swap_eq_iff_eq_swap.symm).trans h.symm.ne_lt
 #align ordering.compares.ne_gt Ordering.Compares.ne_gt
 
-/- warning: ordering.compares.le_total -> Ordering.Compares.le_total is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Or (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Or (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align ordering.compares.le_total Ordering.Compares.le_totalₓ'. -/
 theorem Compares.le_total [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b ∨ b ≤ a
   | lt, h => Or.inl (le_of_lt h)
   | Eq, h => Or.inl (le_of_eq h)
   | GT.gt, h => Or.inr (le_of_lt h)
 #align ordering.compares.le_total Ordering.Compares.le_total
 
-/- warning: ordering.compares.le_antisymm -> Ordering.Compares.le_antisymm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a) -> (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a) -> (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align ordering.compares.le_antisymm Ordering.Compares.le_antisymmₓ'. -/
 theorem Compares.le_antisymm [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b → b ≤ a → a = b
   | lt, h, _, hba => (not_le_of_lt h hba).elim
   | Eq, h, _, _ => h
   | GT.gt, h, hab, _ => (not_le_of_lt h hab).elim
 #align ordering.compares.le_antisymm Ordering.Compares.le_antisymm
 
-/- warning: ordering.compares.inj -> Ordering.Compares.inj is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o₁ : Ordering} {o₂ : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o₁ a b) -> (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o₂ a b) -> (Eq.{1} Ordering o₁ o₂)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o₁ : Ordering} {o₂ : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o₁ a b) -> (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o₂ a b) -> (Eq.{1} Ordering o₁ o₂)
-Case conversion may be inaccurate. Consider using '#align ordering.compares.inj Ordering.Compares.injₓ'. -/
 theorem Compares.inj [Preorder α] {o₁} :
     ∀ {o₂} {a b : α}, Compares o₁ a b → Compares o₂ a b → o₁ = o₂
   | lt, a, b, h₁, h₂ => h₁.eq_lt.2 h₂
@@ -189,12 +135,6 @@ theorem Compares.inj [Preorder α] {o₁} :
   | GT.gt, a, b, h₁, h₂ => h₁.eq_gt.2 h₂
 #align ordering.compares.inj Ordering.Compares.inj
 
-/- warning: ordering.compares_iff_of_compares_impl -> Ordering.compares_iff_of_compares_impl is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : α} {a' : β} {b' : β}, (forall {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) -> (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o a' b')) -> (forall (o : Ordering), Iff (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o a' b'))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : α} {a' : β} {b' : β}, (forall {o : Ordering}, (Ordering.Compares.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) o a b) -> (Ordering.Compares.{u1} β (Preorder.toLT.{u1} β _inst_2) o a' b')) -> (forall (o : Ordering), Iff (Ordering.Compares.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) o a b) (Ordering.Compares.{u1} β (Preorder.toLT.{u1} β _inst_2) o a' b'))
-Case conversion may be inaccurate. Consider using '#align ordering.compares_iff_of_compares_impl Ordering.compares_iff_of_compares_implₓ'. -/
 theorem compares_iff_of_compares_impl {β : Type _} [LinearOrder α] [Preorder β] {a b : α}
     {a' b' : β} (h : ∀ {o}, Compares o a b → Compares o a' b') (o) :
     Compares o a b ↔ Compares o a' b' :=
@@ -248,23 +188,11 @@ theorem cmp_compares [LinearOrder α] (a b : α) : (cmp a b).Compares a b := by
 #align cmp_compares cmp_compares
 -/
 
-/- warning: ordering.compares.cmp_eq -> Ordering.Compares.cmp_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) a b) o)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_1 a b) a b) o)
-Case conversion may be inaccurate. Consider using '#align ordering.compares.cmp_eq Ordering.Compares.cmp_eqₓ'. -/
 theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h : o.Compares a b) :
     cmp a b = o :=
   (cmp_compares a b).inj h
 #align ordering.compares.cmp_eq Ordering.Compares.cmp_eq
 
-/- warning: cmp_swap -> cmp_swap is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))] (a : α) (b : α), Eq.{1} Ordering (Ordering.swap (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) a b)) (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2326 : α) (x._@.Mathlib.Order.Compare._hyg.2328 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.2326 x._@.Mathlib.Order.Compare._hyg.2328)] (a : α) (b : α), Eq.{1} Ordering (Ordering.swap (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) a b)) (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) b a)
-Case conversion may be inaccurate. Consider using '#align cmp_swap cmp_swapₓ'. -/
 @[simp]
 theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).symm = cmp b a :=
   by
@@ -290,11 +218,6 @@ theorem cmpLE_ofDual [LE α] [@DecidableRel α (· ≤ ·)] (x y : αᵒᵈ) :
 -/
 
 /- warning: cmp_to_dual clashes with cmp_le_to_dual -> cmpLE_toDual
-warning: cmp_to_dual -> cmpLE_toDual is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : α) (y : α), Eq.{1} Ordering (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2487 : α) (x._@.Mathlib.Order.Compare._hyg.2489 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2487 x._@.Mathlib.Order.Compare._hyg.2489)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) x) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmpLE.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_to_dual cmpLE_toDualₓ'. -/
 @[simp]
 theorem cmpLE_toDual [LT α] [@DecidableRel α (· < ·)] (x y : α) :
@@ -303,11 +226,6 @@ theorem cmpLE_toDual [LT α] [@DecidableRel α (· < ·)] (x y : α) :
 #align cmp_to_dual cmpLE_toDual
 
 /- warning: cmp_of_dual clashes with cmp_le_of_dual -> cmpLE_ofDual
-warning: cmp_of_dual -> cmpLE_ofDual is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2532 : α) (x._@.Mathlib.Order.Compare._hyg.2534 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2532 x._@.Mathlib.Order.Compare._hyg.2534)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) x) _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmpLE.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_of_dual cmpLE_ofDualₓ'. -/
 @[simp]
 theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :
@@ -315,12 +233,6 @@ theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :
   rfl
 #align cmp_of_dual cmpLE_ofDual
 
-/- warning: linear_order_of_compares -> linearOrderOfCompares is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (cmp : α -> α -> Ordering), (forall (a : α) (b : α), Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (cmp a b) a b) -> (LinearOrder.{u1} α)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (cmp : α -> α -> Ordering), (forall (a : α) (b : α), Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) (cmp a b) a b) -> (LinearOrder.{u1} α)
-Case conversion may be inaccurate. Consider using '#align linear_order_of_compares linearOrderOfComparesₓ'. -/
 /-- Generate a linear order structure from a preorder and `cmp` function. -/
 def linearOrderOfCompares [Preorder α] (cmp : α → α → Ordering)
     (h : ∀ a b, (cmp a b).Compares a b) : LinearOrder α :=
@@ -363,65 +275,29 @@ theorem cmp_self_eq_eq : cmp x x = Ordering.eq := by rw [cmp_eq_eq_iff]
 
 variable {x y} {β : Type _} [LinearOrder β] {x' y' : β}
 
-/- warning: cmp_eq_cmp_symm -> cmp_eq_cmp_symm is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, Iff (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) y x) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) y' x'))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, Iff (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) y x) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) y' x'))
-Case conversion may be inaccurate. Consider using '#align cmp_eq_cmp_symm cmp_eq_cmp_symmₓ'. -/
 theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x' := by
   rw [← cmp_swap x', ← cmp_swap x, swap_inj]
 #align cmp_eq_cmp_symm cmp_eq_cmp_symm
 
-/- warning: lt_iff_lt_of_cmp_eq_cmp -> lt_iff_lt_of_cmp_eq_cmp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) x' y'))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) -> (Iff (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) x y) (LT.lt.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) x' y'))
-Case conversion may be inaccurate. Consider using '#align lt_iff_lt_of_cmp_eq_cmp lt_iff_lt_of_cmp_eq_cmpₓ'. -/
 theorem lt_iff_lt_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x < y ↔ x' < y' := by
   rw [← cmp_eq_lt_iff, ← cmp_eq_lt_iff, h]
 #align lt_iff_lt_of_cmp_eq_cmp lt_iff_lt_of_cmp_eq_cmp
 
-/- warning: le_iff_le_of_cmp_eq_cmp -> le_iff_le_of_cmp_eq_cmp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) x' y'))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) -> (Iff (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) x y) (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) x' y'))
-Case conversion may be inaccurate. Consider using '#align le_iff_le_of_cmp_eq_cmp le_iff_le_of_cmp_eq_cmpₓ'. -/
 theorem le_iff_le_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x ≤ y ↔ x' ≤ y' :=
   by
   rw [← not_lt, ← not_lt]; apply not_congr
   apply lt_iff_lt_of_cmp_eq_cmp; rwa [cmp_eq_cmp_symm]
 #align le_iff_le_of_cmp_eq_cmp le_iff_le_of_cmp_eq_cmp
 
-/- warning: eq_iff_eq_of_cmp_eq_cmp -> eq_iff_eq_of_cmp_eq_cmp is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (Eq.{succ u1} α x y) (Eq.{succ u2} β x' y'))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) -> (Iff (Eq.{succ u2} α x y) (Eq.{succ u1} β x' y'))
-Case conversion may be inaccurate. Consider using '#align eq_iff_eq_of_cmp_eq_cmp eq_iff_eq_of_cmp_eq_cmpₓ'. -/
 theorem eq_iff_eq_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x = y ↔ x' = y' := by
   rw [le_antisymm_iff, le_antisymm_iff, le_iff_le_of_cmp_eq_cmp h,
     le_iff_le_of_cmp_eq_cmp (cmp_eq_cmp_symm.1 h)]
 #align eq_iff_eq_of_cmp_eq_cmp eq_iff_eq_of_cmp_eq_cmp
 
-/- warning: has_lt.lt.cmp_eq_lt -> LT.lt.cmp_eq_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) Ordering.lt)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_1 a b) x y) Ordering.lt)
-Case conversion may be inaccurate. Consider using '#align has_lt.lt.cmp_eq_lt LT.lt.cmp_eq_ltₓ'. -/
 theorem LT.lt.cmp_eq_lt (h : x < y) : cmp x y = Ordering.lt :=
   (cmp_eq_lt_iff _ _).2 h
 #align has_lt.lt.cmp_eq_lt LT.lt.cmp_eq_lt
 
-/- warning: has_lt.lt.cmp_eq_gt -> LT.lt.cmp_eq_gt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) y x) Ordering.gt)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_1 a b) y x) Ordering.gt)
-Case conversion may be inaccurate. Consider using '#align has_lt.lt.cmp_eq_gt LT.lt.cmp_eq_gtₓ'. -/
 theorem LT.lt.cmp_eq_gt (h : x < y) : cmp y x = Ordering.gt :=
   (cmp_eq_gt_iff _ _).2 h
 #align has_lt.lt.cmp_eq_gt LT.lt.cmp_eq_gt

448144f7

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -74,10 +74,8 @@ def Compares [LT α] : Ordering → α → α → Prop
 -/
 
 #print Ordering.compares_swap /-
-theorem compares_swap [LT α] {a b : α} {o : Ordering} : o.symm.Compares a b ↔ o.Compares b a :=
-  by
-  cases o
-  exacts[Iff.rfl, eq_comm, Iff.rfl]
+theorem compares_swap [LT α] {a b : α} {o : Ordering} : o.symm.Compares a b ↔ o.Compares b a := by
+  cases o; exacts[Iff.rfl, eq_comm, Iff.rfl]
 #align ordering.compares_swap Ordering.compares_swap
 -/
 
@@ -231,9 +229,7 @@ open Ordering OrderDual
 #print toDual_compares_toDual /-
 @[simp]
 theorem toDual_compares_toDual [LT α] {a b : α} {o : Ordering} :
-    Compares o (toDual a) (toDual b) ↔ Compares o b a :=
-  by
-  cases o
+    Compares o (toDual a) (toDual b) ↔ Compares o b a := by cases o;
   exacts[Iff.rfl, eq_comm, Iff.rfl]
 #align to_dual_compares_to_dual toDual_compares_toDual
 -/
@@ -241,9 +237,7 @@ theorem toDual_compares_toDual [LT α] {a b : α} {o : Ordering} :
 #print ofDual_compares_ofDual /-
 @[simp]
 theorem ofDual_compares_ofDual [LT α] {a b : αᵒᵈ} {o : Ordering} :
-    Compares o (ofDual a) (ofDual b) ↔ Compares o b a :=
-  by
-  cases o
+    Compares o (ofDual a) (ofDual b) ↔ Compares o b a := by cases o;
   exacts[Iff.rfl, eq_comm, Iff.rfl]
 #align of_dual_compares_of_dual ofDual_compares_ofDual
 -/
@@ -397,10 +391,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align le_iff_le_of_cmp_eq_cmp le_iff_le_of_cmp_eq_cmpₓ'. -/
 theorem le_iff_le_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x ≤ y ↔ x' ≤ y' :=
   by
-  rw [← not_lt, ← not_lt]
-  apply not_congr
-  apply lt_iff_lt_of_cmp_eq_cmp
-  rwa [cmp_eq_cmp_symm]
+  rw [← not_lt, ← not_lt]; apply not_congr
+  apply lt_iff_lt_of_cmp_eq_cmp; rwa [cmp_eq_cmp_symm]
 #align le_iff_le_of_cmp_eq_cmp le_iff_le_of_cmp_eq_cmp
 
 /- warning: eq_iff_eq_of_cmp_eq_cmp -> eq_iff_eq_of_cmp_eq_cmp is a dubious translation:

448144f7

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -269,7 +269,7 @@ theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h :
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))] (a : α) (b : α), Eq.{1} Ordering (Ordering.swap (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) a b)) (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) b a)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2319 : α) (x._@.Mathlib.Order.Compare._hyg.2321 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.2319 x._@.Mathlib.Order.Compare._hyg.2321)] (a : α) (b : α), Eq.{1} Ordering (Ordering.swap (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) a b)) (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) b a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2326 : α) (x._@.Mathlib.Order.Compare._hyg.2328 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.2326 x._@.Mathlib.Order.Compare._hyg.2328)] (a : α) (b : α), Eq.{1} Ordering (Ordering.swap (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) a b)) (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) b a)
 Case conversion may be inaccurate. Consider using '#align cmp_swap cmp_swapₓ'. -/
 @[simp]
 theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).symm = cmp b a :=
@@ -300,7 +300,7 @@ warning: cmp_to_dual -> cmpLE_toDual is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : α) (y : α), Eq.{1} Ordering (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2480 : α) (x._@.Mathlib.Order.Compare._hyg.2482 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2480 x._@.Mathlib.Order.Compare._hyg.2482)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) x) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmpLE.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2487 : α) (x._@.Mathlib.Order.Compare._hyg.2489 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2487 x._@.Mathlib.Order.Compare._hyg.2489)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) x) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmpLE.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_to_dual cmpLE_toDualₓ'. -/
 @[simp]
 theorem cmpLE_toDual [LT α] [@DecidableRel α (· < ·)] (x y : α) :
@@ -313,7 +313,7 @@ warning: cmp_of_dual -> cmpLE_ofDual is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2525 : α) (x._@.Mathlib.Order.Compare._hyg.2527 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2525 x._@.Mathlib.Order.Compare._hyg.2527)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) x) _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmpLE.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2532 : α) (x._@.Mathlib.Order.Compare._hyg.2534 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2532 x._@.Mathlib.Order.Compare._hyg.2534)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) x) _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmpLE.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_of_dual cmpLE_ofDualₓ'. -/
 @[simp]
 theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -47,14 +47,18 @@ theorem cmpLE_swap {α} [LE α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· 
 #align cmp_le_swap cmpLE_swap
 -/
 
-#print cmpLE_eq_cmp /-
+/- warning: cmp_le_eq_cmp -> cmpLE_eq_cmp is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTotal.{u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))] [_inst_3 : DecidableRel.{succ u1} α (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1))] [_inst_4 : DecidableRel.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_3 a b) x y) (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_4 a b) x y)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : IsTotal.{u1} α (fun (x._@.Mathlib.Order.Compare._hyg.273 : α) (x._@.Mathlib.Order.Compare._hyg.275 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.273 x._@.Mathlib.Order.Compare._hyg.275)] [_inst_3 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.291 : α) (x._@.Mathlib.Order.Compare._hyg.293 : α) => LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.291 x._@.Mathlib.Order.Compare._hyg.293)] [_inst_4 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.309 : α) (x._@.Mathlib.Order.Compare._hyg.311 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.309 x._@.Mathlib.Order.Compare._hyg.311)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} α (Preorder.toLE.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_3 a b) x y) (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_4 a b) x y)
+Case conversion may be inaccurate. Consider using '#align cmp_le_eq_cmp cmpLE_eq_cmpₓ'. -/
 theorem cmpLE_eq_cmp {α} [Preorder α] [IsTotal α (· ≤ ·)] [@DecidableRel α (· ≤ ·)]
     [@DecidableRel α (· < ·)] (x y : α) : cmpLE x y = cmp x y :=
   by
   by_cases xy : x ≤ y <;> by_cases yx : y ≤ x <;> simp [cmpLE, lt_iff_le_not_le, *, cmp, cmpUsing]
   cases not_or_of_not xy yx (total_of _ _ _)
 #align cmp_le_eq_cmp cmpLE_eq_cmp
--/
 
 namespace Ordering
 
@@ -94,70 +98,102 @@ theorem swap_eq_iff_eq_swap {o o' : Ordering} : o.symm = o' ↔ o = o'.symm := b
 #align ordering.swap_eq_iff_eq_swap Ordering.swap_eq_iff_eq_swap
 -/
 
-#print Ordering.Compares.eq_lt /-
+/- warning: ordering.compares.eq_lt -> Ordering.Compares.eq_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.lt) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.lt) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align ordering.compares.eq_lt Ordering.Compares.eq_ltₓ'. -/
 theorem Compares.eq_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = lt ↔ a < b)
   | lt, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | Eq, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h' h).elim⟩
   | GT.gt, a, b, h => ⟨fun h => by injection h, fun h' => (lt_asymm h h').elim⟩
 #align ordering.compares.eq_lt Ordering.Compares.eq_lt
--/
 
-#print Ordering.Compares.ne_lt /-
+/- warning: ordering.compares.ne_lt -> Ordering.Compares.ne_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.lt) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.lt) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align ordering.compares.ne_lt Ordering.Compares.ne_ltₓ'. -/
 theorem Compares.ne_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o ≠ lt ↔ b ≤ a)
   | lt, a, b, h => ⟨absurd rfl, fun h' => (not_le_of_lt h h').elim⟩
   | Eq, a, b, h => ⟨fun _ => ge_of_eq h, fun _ h => by injection h⟩
   | GT.gt, a, b, h => ⟨fun _ => le_of_lt h, fun _ h => by injection h⟩
 #align ordering.compares.ne_lt Ordering.Compares.ne_lt
--/
 
-#print Ordering.Compares.eq_eq /-
+/- warning: ordering.compares.eq_eq -> Ordering.Compares.eq_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.eq) (Eq.{succ u1} α a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.eq) (Eq.{succ u1} α a b))
+Case conversion may be inaccurate. Consider using '#align ordering.compares.eq_eq Ordering.Compares.eq_eqₓ'. -/
 theorem Compares.eq_eq [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = eq ↔ a = b)
   | lt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h h').elim⟩
   | Eq, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | GT.gt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_gt h h').elim⟩
 #align ordering.compares.eq_eq Ordering.Compares.eq_eq
--/
 
-#print Ordering.Compares.eq_gt /-
+/- warning: ordering.compares.eq_gt -> Ordering.Compares.eq_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.gt) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Eq.{1} Ordering o Ordering.gt) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align ordering.compares.eq_gt Ordering.Compares.eq_gtₓ'. -/
 theorem Compares.eq_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o = gt ↔ b < a :=
   swap_eq_iff_eq_swap.symm.trans h.symm.eq_lt
 #align ordering.compares.eq_gt Ordering.Compares.eq_gt
--/
 
-#print Ordering.Compares.ne_gt /-
+/- warning: ordering.compares.ne_gt -> Ordering.Compares.ne_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.gt) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Iff (Ne.{1} Ordering o Ordering.gt) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align ordering.compares.ne_gt Ordering.Compares.ne_gtₓ'. -/
 theorem Compares.ne_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o ≠ gt ↔ a ≤ b :=
   (not_congr swap_eq_iff_eq_swap.symm).trans h.symm.ne_lt
 #align ordering.compares.ne_gt Ordering.Compares.ne_gt
--/
 
-#print Ordering.Compares.le_total /-
+/- warning: ordering.compares.le_total -> Ordering.Compares.le_total is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (Or (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (Or (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align ordering.compares.le_total Ordering.Compares.le_totalₓ'. -/
 theorem Compares.le_total [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b ∨ b ≤ a
   | lt, h => Or.inl (le_of_lt h)
   | Eq, h => Or.inl (le_of_eq h)
   | GT.gt, h => Or.inr (le_of_lt h)
 #align ordering.compares.le_total Ordering.Compares.le_total
--/
 
-#print Ordering.Compares.le_antisymm /-
+/- warning: ordering.compares.le_antisymm -> Ordering.Compares.le_antisymm is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a) -> (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a) -> (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align ordering.compares.le_antisymm Ordering.Compares.le_antisymmₓ'. -/
 theorem Compares.le_antisymm [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b → b ≤ a → a = b
   | lt, h, _, hba => (not_le_of_lt h hba).elim
   | Eq, h, _, _ => h
   | GT.gt, h, hab, _ => (not_le_of_lt h hab).elim
 #align ordering.compares.le_antisymm Ordering.Compares.le_antisymm
--/
 
-#print Ordering.Compares.inj /-
+/- warning: ordering.compares.inj -> Ordering.Compares.inj is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o₁ : Ordering} {o₂ : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o₁ a b) -> (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) o₂ a b) -> (Eq.{1} Ordering o₁ o₂)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {o₁ : Ordering} {o₂ : Ordering} {a : α} {b : α}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o₁ a b) -> (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) o₂ a b) -> (Eq.{1} Ordering o₁ o₂)
+Case conversion may be inaccurate. Consider using '#align ordering.compares.inj Ordering.Compares.injₓ'. -/
 theorem Compares.inj [Preorder α] {o₁} :
     ∀ {o₂} {a b : α}, Compares o₁ a b → Compares o₂ a b → o₁ = o₂
   | lt, a, b, h₁, h₂ => h₁.eq_lt.2 h₂
   | Eq, a, b, h₁, h₂ => h₁.eq_eq.2 h₂
   | GT.gt, a, b, h₁, h₂ => h₁.eq_gt.2 h₂
 #align ordering.compares.inj Ordering.Compares.inj
--/
 
 /- warning: ordering.compares_iff_of_compares_impl -> Ordering.compares_iff_of_compares_impl is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : α} {a' : β} {b' : β}, (forall {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) -> (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o a' b')) -> (forall (o : Ordering), Iff (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) (Ordering.Compares.{u2} β (Preorder.toLT.{u2} β _inst_2) o a' b'))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LinearOrder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : α} {a' : β} {b' : β}, (forall {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) -> (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o a' b')) -> (forall (o : Ordering), Iff (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) (Ordering.Compares.{u2} β (Preorder.toHasLt.{u2} β _inst_2) o a' b'))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LinearOrder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : α} {a' : β} {b' : β}, (forall {o : Ordering}, (Ordering.Compares.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) o a b) -> (Ordering.Compares.{u1} β (Preorder.toLT.{u1} β _inst_2) o a' b')) -> (forall (o : Ordering), Iff (Ordering.Compares.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) o a b) (Ordering.Compares.{u1} β (Preorder.toLT.{u1} β _inst_2) o a' b'))
 Case conversion may be inaccurate. Consider using '#align ordering.compares_iff_of_compares_impl Ordering.compares_iff_of_compares_implₓ'. -/
@@ -218,14 +254,23 @@ theorem cmp_compares [LinearOrder α] (a b : α) : (cmp a b).Compares a b := by
 #align cmp_compares cmp_compares
 -/
 
-#print Ordering.Compares.cmp_eq /-
+/- warning: ordering.compares.cmp_eq -> Ordering.Compares.cmp_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) a b) o)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {a : α} {b : α} {o : Ordering}, (Ordering.Compares.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) o a b) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_1 a b) a b) o)
+Case conversion may be inaccurate. Consider using '#align ordering.compares.cmp_eq Ordering.Compares.cmp_eqₓ'. -/
 theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h : o.Compares a b) :
     cmp a b = o :=
   (cmp_compares a b).inj h
 #align ordering.compares.cmp_eq Ordering.Compares.cmp_eq
--/
 
-#print cmp_swap /-
+/- warning: cmp_swap -> cmp_swap is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1))] (a : α) (b : α), Eq.{1} Ordering (Ordering.swap (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) a b)) (cmp.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) b a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2319 : α) (x._@.Mathlib.Order.Compare._hyg.2321 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) x._@.Mathlib.Order.Compare._hyg.2319 x._@.Mathlib.Order.Compare._hyg.2321)] (a : α) (b : α), Eq.{1} Ordering (Ordering.swap (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) a b)) (cmp.{u1} α (Preorder.toLT.{u1} α _inst_1) (fun (a : α) (b : α) => _inst_2 a b) b a)
+Case conversion may be inaccurate. Consider using '#align cmp_swap cmp_swapₓ'. -/
 @[simp]
 theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).symm = cmp b a :=
   by
@@ -233,7 +278,6 @@ theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a
   by_cases a < b <;> by_cases h₂ : b < a <;> simp [h, h₂, Ordering.swap]
   exact lt_asymm h h₂
 #align cmp_swap cmp_swap
--/
 
 #print cmpLE_toDual /-
 @[simp]
@@ -277,7 +321,12 @@ theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :
   rfl
 #align cmp_of_dual cmpLE_ofDual
 
-#print linearOrderOfCompares /-
+/- warning: linear_order_of_compares -> linearOrderOfCompares is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (cmp : α -> α -> Ordering), (forall (a : α) (b : α), Ordering.Compares.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (cmp a b) a b) -> (LinearOrder.{u1} α)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (cmp : α -> α -> Ordering), (forall (a : α) (b : α), Ordering.Compares.{u1} α (Preorder.toLT.{u1} α _inst_1) (cmp a b) a b) -> (LinearOrder.{u1} α)
+Case conversion may be inaccurate. Consider using '#align linear_order_of_compares linearOrderOfComparesₓ'. -/
 /-- Generate a linear order structure from a preorder and `cmp` function. -/
 def linearOrderOfCompares [Preorder α] (cmp : α → α → Ordering)
     (h : ∀ a b, (cmp a b).Compares a b) : LinearOrder α :=
@@ -288,7 +337,6 @@ def linearOrderOfCompares [Preorder α] (cmp : α → α → Ordering)
     decidableLt := fun a b => decidable_of_iff _ (h a b).eq_lt
     DecidableEq := fun a b => decidable_of_iff _ (h a b).eq_eq }
 #align linear_order_of_compares linearOrderOfCompares
--/
 
 variable [LinearOrder α] (x y : α)
 
@@ -323,7 +371,7 @@ variable {x y} {β : Type _} [LinearOrder β] {x' y' : β}
 
 /- warning: cmp_eq_cmp_symm -> cmp_eq_cmp_symm is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, Iff (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) y x) (cmp.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) y' x'))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, Iff (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) y x) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) y' x'))
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, Iff (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) y x) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) y' x'))
 Case conversion may be inaccurate. Consider using '#align cmp_eq_cmp_symm cmp_eq_cmp_symmₓ'. -/
@@ -333,7 +381,7 @@ theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x' := by
 
 /- warning: lt_iff_lt_of_cmp_eq_cmp -> lt_iff_lt_of_cmp_eq_cmp is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) (LT.lt.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) x' y'))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) (LT.lt.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) x' y'))
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) -> (Iff (LT.lt.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) x y) (LT.lt.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) x' y'))
 Case conversion may be inaccurate. Consider using '#align lt_iff_lt_of_cmp_eq_cmp lt_iff_lt_of_cmp_eq_cmpₓ'. -/
@@ -343,7 +391,7 @@ theorem lt_iff_lt_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x < y ↔ x' < y' :=
 
 /- warning: le_iff_le_of_cmp_eq_cmp -> le_iff_le_of_cmp_eq_cmp is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) (LE.le.{u2} β (Preorder.toLE.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) x' y'))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) (LE.le.{u2} β (Preorder.toHasLe.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) x' y'))
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) -> (Iff (LE.le.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) x y) (LE.le.{u1} β (Preorder.toLE.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) x' y'))
 Case conversion may be inaccurate. Consider using '#align le_iff_le_of_cmp_eq_cmp le_iff_le_of_cmp_eq_cmpₓ'. -/
@@ -357,7 +405,7 @@ theorem le_iff_le_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x ≤ y ↔ x' ≤ y
 
 /- warning: eq_iff_eq_of_cmp_eq_cmp -> eq_iff_eq_of_cmp_eq_cmp is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toLT.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (Eq.{succ u1} α x y) (Eq.{succ u2} β x' y'))
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α} {β : Type.{u2}} [_inst_2 : LinearOrder.{u2} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) (cmp.{u2} β (Preorder.toHasLt.{u2} β (PartialOrder.toPreorder.{u2} β (LinearOrder.toPartialOrder.{u2} β _inst_2))) (fun (a : β) (b : β) => LT.lt.decidable.{u2} β _inst_2 a b) x' y')) -> (Iff (Eq.{succ u1} α x y) (Eq.{succ u2} β x' y'))
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : LinearOrder.{u2} α] {x : α} {y : α} {β : Type.{u1}} [_inst_2 : LinearOrder.{u1} β] {x' : β} {y' : β}, (Eq.{1} Ordering (cmp.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α (LinearOrder.toPartialOrder.{u2} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u2} α _inst_1 a b) x y) (cmp.{u1} β (Preorder.toLT.{u1} β (PartialOrder.toPreorder.{u1} β (LinearOrder.toPartialOrder.{u1} β _inst_2))) (fun (a : β) (b : β) => instDecidableLtToLTToPreorderToPartialOrder.{u1} β _inst_2 a b) x' y')) -> (Iff (Eq.{succ u2} α x y) (Eq.{succ u1} β x' y'))
 Case conversion may be inaccurate. Consider using '#align eq_iff_eq_of_cmp_eq_cmp eq_iff_eq_of_cmp_eq_cmpₓ'. -/
@@ -366,17 +414,25 @@ theorem eq_iff_eq_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x = y ↔ x' = y' :=
     le_iff_le_of_cmp_eq_cmp (cmp_eq_cmp_symm.1 h)]
 #align eq_iff_eq_of_cmp_eq_cmp eq_iff_eq_of_cmp_eq_cmp
 
-#print LT.lt.cmp_eq_lt /-
+/- warning: has_lt.lt.cmp_eq_lt -> LT.lt.cmp_eq_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) x y) Ordering.lt)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_1 a b) x y) Ordering.lt)
+Case conversion may be inaccurate. Consider using '#align has_lt.lt.cmp_eq_lt LT.lt.cmp_eq_ltₓ'. -/
 theorem LT.lt.cmp_eq_lt (h : x < y) : cmp x y = Ordering.lt :=
   (cmp_eq_lt_iff _ _).2 h
 #align has_lt.lt.cmp_eq_lt LT.lt.cmp_eq_lt
--/
 
-#print LT.lt.cmp_eq_gt /-
+/- warning: has_lt.lt.cmp_eq_gt -> LT.lt.cmp_eq_gt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => LT.lt.decidable.{u1} α _inst_1 a b) y x) Ordering.gt)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] {x : α} {y : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) x y) -> (Eq.{1} Ordering (cmp.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))) (fun (a : α) (b : α) => instDecidableLtToLTToPreorderToPartialOrder.{u1} α _inst_1 a b) y x) Ordering.gt)
+Case conversion may be inaccurate. Consider using '#align has_lt.lt.cmp_eq_gt LT.lt.cmp_eq_gtₓ'. -/
 theorem LT.lt.cmp_eq_gt (h : x < y) : cmp y x = Ordering.gt :=
   (cmp_eq_gt_iff _ _).2 h
 #align has_lt.lt.cmp_eq_gt LT.lt.cmp_eq_gt
--/
 
 #print Eq.cmp_eq_eq /-
 theorem Eq.cmp_eq_eq (h : x = y) : cmp x y = Ordering.eq :=

448144f7

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -256,7 +256,7 @@ warning: cmp_to_dual -> cmpLE_toDual is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : α) (y : α), Eq.{1} Ordering (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2476 : α) (x._@.Mathlib.Order.Compare._hyg.2478 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2476 x._@.Mathlib.Order.Compare._hyg.2478)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) x) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmpLE.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2480 : α) (x._@.Mathlib.Order.Compare._hyg.2482 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2480 x._@.Mathlib.Order.Compare._hyg.2482)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) x) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmpLE.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_to_dual cmpLE_toDualₓ'. -/
 @[simp]
 theorem cmpLE_toDual [LT α] [@DecidableRel α (· < ·)] (x y : α) :
@@ -269,7 +269,7 @@ warning: cmp_of_dual -> cmpLE_ofDual is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2519 : α) (x._@.Mathlib.Order.Compare._hyg.2521 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2519 x._@.Mathlib.Order.Compare._hyg.2521)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) x) _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmpLE.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2525 : α) (x._@.Mathlib.Order.Compare._hyg.2527 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2525 x._@.Mathlib.Order.Compare._hyg.2527)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) x) _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmpLE.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_of_dual cmpLE_ofDualₓ'. -/
 @[simp]
 theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :

448144f7

bump to nightly-2023-03-08-16

mathlib commit https://github.com/leanprover-community/mathlib/commit/38f16f960f5006c6c0c2bac7b0aba5273188f4e5

593337bd

Diff

@@ -256,7 +256,7 @@ warning: cmp_to_dual -> cmpLE_toDual is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : α) (y : α), Eq.{1} Ordering (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (fun (_x : Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) => α -> (OrderDual.{u1} α)) (Equiv.hasCoeToFun.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2478 : α) (x._@.Mathlib.Order.Compare._hyg.2480 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2478 x._@.Mathlib.Order.Compare._hyg.2480)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) x) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmpLE.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2476 : α) (x._@.Mathlib.Order.Compare._hyg.2478 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2476 x._@.Mathlib.Order.Compare._hyg.2478)] (x : α) (y : α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) x) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} α (OrderDual.{u1} α)) α (fun (_x : α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : α) => OrderDual.{u1} α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} α (OrderDual.{u1} α)) (OrderDual.toDual.{u1} α) y)) (cmpLE.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_to_dual cmpLE_toDualₓ'. -/
 @[simp]
 theorem cmpLE_toDual [LT α] [@DecidableRel α (· < ·)] (x y : α) :
@@ -269,7 +269,7 @@ warning: cmp_of_dual -> cmpLE_ofDual is a dubious translation:
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : LT.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (LT.lt.{u1} α _inst_1)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmp.{u1} α _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (coeFn.{succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (fun (_x : Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) => (OrderDual.{u1} α) -> α) (Equiv.hasCoeToFun.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmp.{u1} (OrderDual.{u1} α) (OrderDual.hasLt.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2521 : α) (x._@.Mathlib.Order.Compare._hyg.2523 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2521 x._@.Mathlib.Order.Compare._hyg.2523)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) x) _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmpLE.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
+  forall {α : Type.{u1}} [_inst_1 : LE.{u1} α] [_inst_2 : DecidableRel.{succ u1} α (fun (x._@.Mathlib.Order.Compare._hyg.2519 : α) (x._@.Mathlib.Order.Compare._hyg.2521 : α) => LE.le.{u1} α _inst_1 x._@.Mathlib.Order.Compare._hyg.2519 x._@.Mathlib.Order.Compare._hyg.2521)] (x : OrderDual.{u1} α) (y : OrderDual.{u1} α), Eq.{1} Ordering (cmpLE.{u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) x) _inst_1 (fun (a : α) (b : α) => _inst_2 a b) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) x) (FunLike.coe.{succ u1, succ u1, succ u1} (Equiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.{u1} α) (fun (_x : OrderDual.{u1} α) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : OrderDual.{u1} α) => α) _x) (Equiv.instFunLikeEquiv.{succ u1, succ u1} (OrderDual.{u1} α) α) (OrderDual.ofDual.{u1} α) y)) (cmpLE.{u1} (OrderDual.{u1} α) (OrderDual.instLEOrderDual.{u1} α _inst_1) (fun (a : OrderDual.{u1} α) (b : OrderDual.{u1} α) => _inst_2 b a) y x)
 Case conversion may be inaccurate. Consider using '#align cmp_of_dual cmpLE_ofDualₓ'. -/
 @[simp]
 theorem cmpLE_ofDual [LT α] [@DecidableRel α (· < ·)] (x y : αᵒᵈ) :

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

c4658a64

chore: exact by decide -> decide (#12067)

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

1e53d4f0

Diff

@@ -143,7 +143,7 @@ theorem swap_orElse (o₁ o₂) : (orElse o₁ o₂).swap = orElse o₁.swap o
 #align ordering.swap_or_else Ordering.swap_orElse
 
 theorem orElse_eq_lt (o₁ o₂) : orElse o₁ o₂ = lt ↔ o₁ = lt ∨ o₁ = eq ∧ o₂ = lt := by
-  cases o₁ <;> cases o₂ <;> exact by decide
+  cases o₁ <;> cases o₂ <;> decide
 #align ordering.or_else_eq_lt Ordering.orElse_eq_lt
 
 end Ordering

c4658a64

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -71,7 +71,7 @@ theorem compares_swap [LT α] {a b : α} {o : Ordering} : o.swap.Compares a b 
   · exact Iff.rfl
 #align ordering.compares_swap Ordering.compares_swap
 
-alias compares_swap ↔ Compares.of_swap Compares.swap
+alias ⟨Compares.of_swap, Compares.swap⟩ := compares_swap
 #align ordering.compares.of_swap Ordering.Compares.of_swap
 #align ordering.compares.swap Ordering.Compares.swap

c4658a64

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

@@ -23,7 +23,7 @@ This file provides basic results about orderings and comparison in linear orders
 -/
 
 
-variable {α β : Type _}
+variable {α β : Type*}
 
 /-- Like `cmp`, but uses a `≤` on the type instead of `<`. Given two elements `x` and `y`, returns a
 three-way comparison result `Ordering`. -/
@@ -241,7 +241,7 @@ theorem cmp_eq_gt_iff : cmp x y = Ordering.gt ↔ y < x :=
 theorem cmp_self_eq_eq : cmp x x = Ordering.eq := by rw [cmp_eq_eq_iff]
 #align cmp_self_eq_eq cmp_self_eq_eq
 
-variable {x y} {β : Type _} [LinearOrder β] {x' y' : β}
+variable {x y} {β : Type*} [LinearOrder β] {x' y' : β}
 
 theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x' :=
   ⟨fun h => by rwa [← cmp_swap x', ← cmp_swap, swap_inj],

c4658a64

chore: fix grammar mistakes (#6121)

a16538af

Diff

@@ -47,7 +47,7 @@ namespace Ordering
 
 /-- `Compares o a b` means that `a` and `b` have the ordering relation `o` between them, assuming
 that the relation `a < b` is defined. -/
--- Porting: note we have removed `@[simp]` here in favour of separate simp lemmas,
+-- Porting note: we have removed `@[simp]` here in favour of separate simp lemmas,
 -- otherwise this definition will unfold to a match.
 def Compares [LT α] : Ordering → α → α → Prop
   | lt, a, b => a < b

c4658a64

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) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
-
-! This file was ported from Lean 3 source module order.compare
-! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Init.Data.Ordering.Basic
 import Mathlib.Order.Synonym
 
+#align_import order.compare from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
+
 /-!
 # Comparison

c4658a64

chore: add space after exacts (#4945)

Too often tempted to change these during other PRs, so doing a mass edit here.

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

bf799bb9

Diff

@@ -157,14 +157,14 @@ open Ordering OrderDual
 theorem toDual_compares_toDual [LT α] {a b : α} {o : Ordering} :
     Compares o (toDual a) (toDual b) ↔ Compares o b a := by
   cases o
-  exacts[Iff.rfl, eq_comm, Iff.rfl]
+  exacts [Iff.rfl, eq_comm, Iff.rfl]
 #align to_dual_compares_to_dual toDual_compares_toDual
 
 @[simp]
 theorem ofDual_compares_ofDual [LT α] {a b : αᵒᵈ} {o : Ordering} :
     Compares o (ofDual a) (ofDual b) ↔ Compares o b a := by
   cases o
-  exacts[Iff.rfl, eq_comm, Iff.rfl]
+  exacts [Iff.rfl, eq_comm, Iff.rfl]
 #align of_dual_compares_of_dual ofDual_compares_ofDual
 
 theorem cmp_compares [LinearOrder α] (a b : α) : (cmp a b).Compares a b := by

c4658a64

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

This renames

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

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

e7280432

Diff

@@ -218,9 +218,9 @@ def linearOrderOfCompares [Preorder α] (cmp : α → α → Ordering)
     le_total := fun a b => (h a b).le_total,
     toMin := minOfLe,
     toMax := maxOfLe,
-    decidable_le := H,
-    decidable_lt := fun a b => decidable_of_iff _ (h a b).eq_lt,
-    decidable_eq := fun a b => decidable_of_iff _ (h a b).eq_eq }
+    decidableLE := H,
+    decidableLT := fun a b => decidable_of_iff _ (h a b).eq_lt,
+    decidableEq := fun a b => decidable_of_iff _ (h a b).eq_eq }
 #align linear_order_of_compares linearOrderOfCompares
 
 variable [LinearOrder α] (x y : α)

c4658a64

chore: add missing hypothesis names to by_cases (#2679)

5d07683a

Diff

@@ -179,7 +179,7 @@ theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h :
 @[simp]
 theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).swap = cmp b a := by
   unfold cmp cmpUsing
-  by_cases a < b <;> by_cases h₂:b < a <;> simp [h, h₂, Ordering.swap]
+  by_cases h : a < b <;> by_cases h₂ : b < a <;> simp [h, h₂, Ordering.swap]
   exact lt_asymm h h₂
 #align cmp_swap cmp_swap

c4658a64

chore: add missing #align statements (#1902)

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

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

b72bb858

Diff

@@ -56,6 +56,7 @@ def Compares [LT α] : Ordering → α → α → Prop
   | lt, a, b => a < b
   | eq, a, b => a = b
   | gt, a, b => a > b
+#align ordering.compares Ordering.Compares
 
 @[simp]
 lemma compares_lt [LT α] (a b : α) : Compares lt a b = (a < b) := rfl
@@ -71,48 +72,60 @@ theorem compares_swap [LT α] {a b : α} {o : Ordering} : o.swap.Compares a b 
   · exact Iff.rfl
   · exact eq_comm
   · exact Iff.rfl
+#align ordering.compares_swap Ordering.compares_swap
 
 alias compares_swap ↔ Compares.of_swap Compares.swap
+#align ordering.compares.of_swap Ordering.Compares.of_swap
+#align ordering.compares.swap Ordering.Compares.swap
 
 theorem swap_eq_iff_eq_swap {o o' : Ordering} : o.swap = o' ↔ o = o'.swap := by
   rw [← swap_inj, swap_swap]
+#align ordering.swap_eq_iff_eq_swap Ordering.swap_eq_iff_eq_swap
 
 theorem Compares.eq_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = lt ↔ a < b)
   | lt, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | eq, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h' h).elim⟩
   | gt, a, b, h => ⟨fun h => by injection h, fun h' => (lt_asymm h h').elim⟩
+#align ordering.compares.eq_lt Ordering.Compares.eq_lt
 
 theorem Compares.ne_lt [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o ≠ lt ↔ b ≤ a)
   | lt, a, b, h => ⟨absurd rfl, fun h' => (not_le_of_lt h h').elim⟩
   | eq, a, b, h => ⟨fun _ => ge_of_eq h, fun _ h => by injection h⟩
   | gt, a, b, h => ⟨fun _ => le_of_lt h, fun _ h => by injection h⟩
+#align ordering.compares.ne_lt Ordering.Compares.ne_lt
 
 theorem Compares.eq_eq [Preorder α] : ∀ {o} {a b : α}, Compares o a b → (o = eq ↔ a = b)
   | lt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_lt h h').elim⟩
   | eq, a, b, h => ⟨fun _ => h, fun _ => rfl⟩
   | gt, a, b, h => ⟨fun h => by injection h, fun h' => (ne_of_gt h h').elim⟩
+#align ordering.compares.eq_eq Ordering.Compares.eq_eq
 
 theorem Compares.eq_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o = gt ↔ b < a :=
   swap_eq_iff_eq_swap.symm.trans h.swap.eq_lt
+#align ordering.compares.eq_gt Ordering.Compares.eq_gt
 
 theorem Compares.ne_gt [Preorder α] {o} {a b : α} (h : Compares o a b) : o ≠ gt ↔ a ≤ b :=
   (not_congr swap_eq_iff_eq_swap.symm).trans h.swap.ne_lt
+#align ordering.compares.ne_gt Ordering.Compares.ne_gt
 
 theorem Compares.le_total [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b ∨ b ≤ a
   | lt, h => Or.inl (le_of_lt h)
   | eq, h => Or.inl (le_of_eq h)
   | gt, h => Or.inr (le_of_lt h)
+#align ordering.compares.le_total Ordering.Compares.le_total
 
 theorem Compares.le_antisymm [Preorder α] {a b : α} : ∀ {o}, Compares o a b → a ≤ b → b ≤ a → a = b
   | lt, h, _, hba => (not_le_of_lt h hba).elim
   | eq, h, _, _ => h
   | gt, h, hab, _ => (not_le_of_lt h hab).elim
+#align ordering.compares.le_antisymm Ordering.Compares.le_antisymm
 
 theorem Compares.inj [Preorder α] {o₁} :
     ∀ {o₂} {a b : α}, Compares o₁ a b → Compares o₂ a b → o₁ = o₂
   | lt, _, _, h₁, h₂ => h₁.eq_lt.2 h₂
   | eq, _, _, h₁, h₂ => h₁.eq_eq.2 h₂
   | gt, _, _, h₁, h₂ => h₁.eq_gt.2 h₂
+#align ordering.compares.inj Ordering.Compares.inj
 
 -- Porting note: mathlib3 proof uses `change ... at hab`
 theorem compares_iff_of_compares_impl [LinearOrder α] [Preorder β] {a b : α} {a' b' : β}
@@ -126,6 +139,7 @@ theorem compares_iff_of_compares_impl [LinearOrder α] [Preorder β] {a b : α}
       rwa [ho.inj (h hab)]
     · have hab : Compares Ordering.gt a b := hab
       rwa [ho.inj (h hab)]
+#align ordering.compares_iff_of_compares_impl Ordering.compares_iff_of_compares_impl
 
 theorem swap_orElse (o₁ o₂) : (orElse o₁ o₂).swap = orElse o₁.swap o₂.swap := by
   cases o₁ <;> rfl
@@ -155,16 +169,19 @@ theorem ofDual_compares_ofDual [LT α] {a b : αᵒᵈ} {o : Ordering} :
 
 theorem cmp_compares [LinearOrder α] (a b : α) : (cmp a b).Compares a b := by
   obtain h | h | h := lt_trichotomy a b <;> simp [cmp, cmpUsing, h, h.not_lt]
+#align cmp_compares cmp_compares
 
 theorem Ordering.Compares.cmp_eq [LinearOrder α] {a b : α} {o : Ordering} (h : o.Compares a b) :
     cmp a b = o :=
   (cmp_compares a b).inj h
+#align ordering.compares.cmp_eq Ordering.Compares.cmp_eq
 
 @[simp]
 theorem cmp_swap [Preorder α] [@DecidableRel α (· < ·)] (a b : α) : (cmp a b).swap = cmp b a := by
   unfold cmp cmpUsing
   by_cases a < b <;> by_cases h₂:b < a <;> simp [h, h₂, Ordering.swap]
   exact lt_asymm h h₂
+#align cmp_swap cmp_swap
 
 -- Porting note: Not sure why the simpNF linter doesn't like this. @semorrison
 @[simp, nolint simpNF]
@@ -204,42 +221,51 @@ def linearOrderOfCompares [Preorder α] (cmp : α → α → Ordering)
     decidable_le := H,
     decidable_lt := fun a b => decidable_of_iff _ (h a b).eq_lt,
     decidable_eq := fun a b => decidable_of_iff _ (h a b).eq_eq }
+#align linear_order_of_compares linearOrderOfCompares
 
 variable [LinearOrder α] (x y : α)
 
 @[simp]
 theorem cmp_eq_lt_iff : cmp x y = Ordering.lt ↔ x < y :=
   Ordering.Compares.eq_lt (cmp_compares x y)
+#align cmp_eq_lt_iff cmp_eq_lt_iff
 
 @[simp]
 theorem cmp_eq_eq_iff : cmp x y = Ordering.eq ↔ x = y :=
   Ordering.Compares.eq_eq (cmp_compares x y)
+#align cmp_eq_eq_iff cmp_eq_eq_iff
 
 @[simp]
 theorem cmp_eq_gt_iff : cmp x y = Ordering.gt ↔ y < x :=
   Ordering.Compares.eq_gt (cmp_compares x y)
+#align cmp_eq_gt_iff cmp_eq_gt_iff
 
 @[simp]
 theorem cmp_self_eq_eq : cmp x x = Ordering.eq := by rw [cmp_eq_eq_iff]
+#align cmp_self_eq_eq cmp_self_eq_eq
 
 variable {x y} {β : Type _} [LinearOrder β] {x' y' : β}
 
 theorem cmp_eq_cmp_symm : cmp x y = cmp x' y' ↔ cmp y x = cmp y' x' :=
   ⟨fun h => by rwa [← cmp_swap x', ← cmp_swap, swap_inj],
    fun h => by rwa [← cmp_swap y', ← cmp_swap, swap_inj]⟩
+#align cmp_eq_cmp_symm cmp_eq_cmp_symm
 
 theorem lt_iff_lt_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x < y ↔ x' < y' := by
   rw [← cmp_eq_lt_iff, ← cmp_eq_lt_iff, h]
+#align lt_iff_lt_of_cmp_eq_cmp lt_iff_lt_of_cmp_eq_cmp
 
 theorem le_iff_le_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x ≤ y ↔ x' ≤ y' := by
   rw [← not_lt, ← not_lt]
   apply not_congr
   apply lt_iff_lt_of_cmp_eq_cmp
   rwa [cmp_eq_cmp_symm]
+#align le_iff_le_of_cmp_eq_cmp le_iff_le_of_cmp_eq_cmp
 
 theorem eq_iff_eq_of_cmp_eq_cmp (h : cmp x y = cmp x' y') : x = y ↔ x' = y' := by
   rw [le_antisymm_iff, le_antisymm_iff, le_iff_le_of_cmp_eq_cmp h,
       le_iff_le_of_cmp_eq_cmp (cmp_eq_cmp_symm.1 h)]
+#align eq_iff_eq_of_cmp_eq_cmp eq_iff_eq_of_cmp_eq_cmp
 
 theorem LT.lt.cmp_eq_lt (h : x < y) : cmp x y = Ordering.lt :=
   (cmp_eq_lt_iff _ _).2 h
@@ -249,6 +275,8 @@ theorem LT.lt.cmp_eq_gt (h : x < y) : cmp y x = Ordering.gt :=
 
 theorem Eq.cmp_eq_eq (h : x = y) : cmp x y = Ordering.eq :=
   (cmp_eq_eq_iff _ _).2 h
+#align eq.cmp_eq_eq Eq.cmp_eq_eq
 
 theorem Eq.cmp_eq_eq' (h : x = y) : cmp y x = Ordering.eq :=
   h.symm.cmp_eq_eq
+#align eq.cmp_eq_eq' Eq.cmp_eq_eq'

c4658a64

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

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

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2017 Mario Carneiro. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Mario Carneiro
+
+! This file was ported from Lean 3 source module order.compare
+! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Init.Data.Ordering.Basic
 import Mathlib.Order.Synonym

`order.compare` ⟷ `Mathlib.Order.Compare`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 15

order.compare ⟷ Mathlib.Order.Compare

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 15

`order.compare` ⟷ `Mathlib.Order.Compare`