data.prod.lex | 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

70d50ecf

(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

@@ -98,10 +98,10 @@ instance preorder (α β : Type _) [Preorder α] [Preorder β] : Preorder (α ×
               · apply lt_asymm hlt; assumption
               · apply lt_irrefl _ hlt
           · constructor
-            · right; rw [lt_iff_le_not_le] at hlt ; exact hlt.1
+            · right; rw [lt_iff_le_not_le] at hlt; exact hlt.1
             · rintro ⟨⟩
               · apply lt_irrefl a₁; assumption
-              · rw [lt_iff_le_not_le] at hlt ; apply hlt.2; assumption
+              · rw [lt_iff_le_not_le] at hlt; apply hlt.2; assumption
         · rintro ⟨⟨⟩, h₂r⟩
           · left; assumption
           · right; rw [lt_iff_le_not_le]; constructor

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) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Minchao Wu
 -/
-import Mathbin.Order.BoundedOrder
+import Order.BoundedOrder
 
 #align_import data.prod.lex from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"

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) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Minchao Wu
-
-! This file was ported from Lean 3 source module data.prod.lex
-! 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.BoundedOrder
 
+#align_import data.prod.lex from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Lexicographic order

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -41,7 +41,6 @@ variable {α β γ : Type _}
 
 namespace Prod.Lex
 
--- mathport name: «expr ×ₗ »
 notation:35 α " ×ₗ " β:34 => Lex (Prod α β)
 
 unsafe instance [has_to_format α] [has_to_format β] : has_to_format (α ×ₗ β) :=
@@ -70,15 +69,19 @@ instance instLT (α β : Type _) [LT α] [LT β] : LT (α ×ₗ β) where lt :=
 #align prod.lex.has_lt Prod.Lex.instLT
 -/
 
+#print Prod.Lex.le_iff /-
 theorem le_iff [LT α] [LE β] (a b : α × β) :
     toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2 :=
   Prod.lex_def (· < ·) (· ≤ ·)
 #align prod.lex.le_iff Prod.Lex.le_iff
+-/
 
+#print Prod.Lex.lt_iff /-
 theorem lt_iff [LT α] [LT β] (a b : α × β) :
     toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2 :=
   Prod.lex_def (· < ·) (· < ·)
 #align prod.lex.lt_iff Prod.Lex.lt_iff
+-/
 
 #print Prod.Lex.preorder /-
 /-- Dictionary / lexicographic preorder for pairs. -/
@@ -114,6 +117,7 @@ section Preorder
 
 variable [PartialOrder α] [Preorder β]
 
+#print Prod.Lex.toLex_mono /-
 theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
   by
   rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⟨ha, hb⟩
@@ -121,7 +125,9 @@ theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
   · exact right _ hb
   · exact left _ _ ha
 #align prod.lex.to_lex_mono Prod.Lex.toLex_mono
+-/
 
+#print Prod.Lex.toLex_strictMono /-
 theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) :=
   by
   rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h
@@ -129,6 +135,7 @@ theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) :=
   · exact right _ (Prod.mk_lt_mk_iff_right.1 h)
   · exact left _ _ ha
 #align prod.lex.to_lex_strict_mono Prod.Lex.toLex_strictMono
+-/
 
 end Preorder

448144f7

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -98,10 +98,10 @@ instance preorder (α β : Type _) [Preorder α] [Preorder β] : Preorder (α ×
               · apply lt_asymm hlt; assumption
               · apply lt_irrefl _ hlt
           · constructor
-            · right; rw [lt_iff_le_not_le] at hlt; exact hlt.1
+            · right; rw [lt_iff_le_not_le] at hlt ; exact hlt.1
             · rintro ⟨⟩
               · apply lt_irrefl a₁; assumption
-              · rw [lt_iff_le_not_le] at hlt; apply hlt.2; assumption
+              · rw [lt_iff_le_not_le] at hlt ; apply hlt.2; assumption
         · rintro ⟨⟨⟩, h₂r⟩
           · left; assumption
           · right; rw [lt_iff_le_not_le]; constructor

448144f7

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -157,22 +157,28 @@ instance linearOrder (α β : Type _) [LinearOrder α] [LinearOrder β] : Linear
 #align prod.lex.linear_order Prod.Lex.linearOrder
 -/
 
+#print Prod.Lex.orderBot /-
 instance orderBot [PartialOrder α] [Preorder β] [OrderBot α] [OrderBot β] : OrderBot (α ×ₗ β)
     where
   bot := toLex ⊥
   bot_le a := toLex_mono bot_le
 #align prod.lex.order_bot Prod.Lex.orderBot
+-/
 
+#print Prod.Lex.orderTop /-
 instance orderTop [PartialOrder α] [Preorder β] [OrderTop α] [OrderTop β] : OrderTop (α ×ₗ β)
     where
   top := toLex ⊤
   le_top a := toLex_mono le_top
 #align prod.lex.order_top Prod.Lex.orderTop
+-/
 
+#print Prod.Lex.boundedOrder /-
 instance boundedOrder [PartialOrder α] [Preorder β] [BoundedOrder α] [BoundedOrder β] :
     BoundedOrder (α ×ₗ β) :=
   { Lex.orderBot, Lex.orderTop with }
 #align prod.lex.bounded_order Prod.Lex.boundedOrder
+-/
 
 instance [Preorder α] [Preorder β] [DenselyOrdered α] [DenselyOrdered β] :
     DenselyOrdered (α ×ₗ β) :=
@@ -183,21 +189,29 @@ instance [Preorder α] [Preorder β] [DenselyOrdered α] [DenselyOrdered β] :
     · obtain ⟨c, h₁, h₂⟩ := exists_between h
       exact ⟨(a, c), right _ h₁, right _ h₂⟩⟩
 
+#print Prod.Lex.noMaxOrder_of_left /-
 instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_gt a; exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_max_order_of_left Prod.Lex.noMaxOrder_of_left
+-/
 
+#print Prod.Lex.noMinOrder_of_left /-
 instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_lt a; exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_min_order_of_left Prod.Lex.noMinOrder_of_left
+-/
 
+#print Prod.Lex.noMaxOrder_of_right /-
 instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_gt b; exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_max_order_of_right Prod.Lex.noMaxOrder_of_right
+-/
 
+#print Prod.Lex.noMinOrder_of_right /-
 instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_lt b; exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_min_order_of_right Prod.Lex.noMinOrder_of_right
+-/
 
 end Prod.Lex

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -70,23 +70,11 @@ instance instLT (α β : Type _) [LT α] [LT β] : LT (α ×ₗ β) where lt :=
 #align prod.lex.has_lt Prod.Lex.instLT
 -/
 
-/- warning: prod.lex.le_iff -> Prod.Lex.le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : LE.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β _inst_1 _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) b)) (Or (LT.lt.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (And (Eq.{succ u1} α (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (LE.le.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LE.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLE.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LE.le.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
-Case conversion may be inaccurate. Consider using '#align prod.lex.le_iff Prod.Lex.le_iffₓ'. -/
 theorem le_iff [LT α] [LE β] (a b : α × β) :
     toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2 :=
   Prod.lex_def (· < ·) (· ≤ ·)
 #align prod.lex.le_iff Prod.Lex.le_iff
 
-/- warning: prod.lex.lt_iff -> Prod.Lex.lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : LT.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β _inst_1 _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) b)) (Or (LT.lt.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (And (Eq.{succ u1} α (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (LT.lt.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b))))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LT.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLT.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LT.lt.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
-Case conversion may be inaccurate. Consider using '#align prod.lex.lt_iff Prod.Lex.lt_iffₓ'. -/
 theorem lt_iff [LT α] [LT β] (a b : α × β) :
     toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2 :=
   Prod.lex_def (· < ·) (· < ·)
@@ -126,12 +114,6 @@ section Preorder
 
 variable [PartialOrder α] [Preorder β]
 
-/- warning: prod.lex.to_lex_mono -> Prod.Lex.toLex_mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β], Monotone.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (Prod.Lex.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], Monotone.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
-Case conversion may be inaccurate. Consider using '#align prod.lex.to_lex_mono Prod.Lex.toLex_monoₓ'. -/
 theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
   by
   rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⟨ha, hb⟩
@@ -140,12 +122,6 @@ theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
   · exact left _ _ ha
 #align prod.lex.to_lex_mono Prod.Lex.toLex_mono
 
-/- warning: prod.lex.to_lex_strict_mono -> Prod.Lex.toLex_strictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β], StrictMono.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (Prod.Lex.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], StrictMono.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
-Case conversion may be inaccurate. Consider using '#align prod.lex.to_lex_strict_mono Prod.Lex.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) :=
   by
   rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h
@@ -181,36 +157,18 @@ instance linearOrder (α β : Type _) [LinearOrder α] [LinearOrder β] : Linear
 #align prod.lex.linear_order Prod.Lex.linearOrder
 -/
 
-/- warning: prod.lex.order_bot -> Prod.Lex.orderBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2)], OrderBot.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toHasLe.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderBot.{u2} β (Preorder.toLE.{u2} β _inst_2)], OrderBot.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align prod.lex.order_bot Prod.Lex.orderBotₓ'. -/
 instance orderBot [PartialOrder α] [Preorder β] [OrderBot α] [OrderBot β] : OrderBot (α ×ₗ β)
     where
   bot := toLex ⊥
   bot_le a := toLex_mono bot_le
 #align prod.lex.order_bot Prod.Lex.orderBot
 
-/- warning: prod.lex.order_top -> Prod.Lex.orderTop is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2)], OrderTop.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toHasLe.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderTop.{u2} β (Preorder.toLE.{u2} β _inst_2)], OrderTop.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align prod.lex.order_top Prod.Lex.orderTopₓ'. -/
 instance orderTop [PartialOrder α] [Preorder β] [OrderTop α] [OrderTop β] : OrderTop (α ×ₗ β)
     where
   top := toLex ⊤
   le_top a := toLex_mono le_top
 #align prod.lex.order_top Prod.Lex.orderTop
 
-/- warning: prod.lex.bounded_order -> Prod.Lex.boundedOrder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : BoundedOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : BoundedOrder.{u2} β (Preorder.toHasLe.{u2} β _inst_2)], BoundedOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toHasLe.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : BoundedOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : BoundedOrder.{u2} β (Preorder.toLE.{u2} β _inst_2)], BoundedOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align prod.lex.bounded_order Prod.Lex.boundedOrderₓ'. -/
 instance boundedOrder [PartialOrder α] [Preorder β] [BoundedOrder α] [BoundedOrder β] :
     BoundedOrder (α ×ₗ β) :=
   { Lex.orderBot, Lex.orderTop with }
@@ -225,42 +183,18 @@ instance [Preorder α] [Preorder β] [DenselyOrdered α] [DenselyOrdered β] :
     · obtain ⟨c, h₁, h₂⟩ := exists_between h
       exact ⟨(a, c), right _ h₁, right _ h₂⟩⟩
 
-/- warning: prod.lex.no_max_order_of_left -> Prod.Lex.noMaxOrder_of_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align prod.lex.no_max_order_of_left Prod.Lex.noMaxOrder_of_leftₓ'. -/
 instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_gt a; exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_max_order_of_left Prod.Lex.noMaxOrder_of_left
 
-/- warning: prod.lex.no_min_order_of_left -> Prod.Lex.noMinOrder_of_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], NoMinOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align prod.lex.no_min_order_of_left Prod.Lex.noMinOrder_of_leftₓ'. -/
 instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_lt a; exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_min_order_of_left Prod.Lex.noMinOrder_of_left
 
-/- warning: prod.lex.no_max_order_of_right -> Prod.Lex.noMaxOrder_of_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u2} β (Preorder.toHasLt.{u2} β _inst_2)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u2} β (Preorder.toLT.{u2} β _inst_2)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align prod.lex.no_max_order_of_right Prod.Lex.noMaxOrder_of_rightₓ'. -/
 instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_gt b; exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_max_order_of_right Prod.Lex.noMaxOrder_of_right
 
-/- warning: prod.lex.no_min_order_of_right -> Prod.Lex.noMinOrder_of_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u2} β (Preorder.toHasLt.{u2} β _inst_2)], NoMinOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
-but is expected to have type
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u2} β (Preorder.toLT.{u2} β _inst_2)], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
-Case conversion may be inaccurate. Consider using '#align prod.lex.no_min_order_of_right Prod.Lex.noMinOrder_of_rightₓ'. -/
 instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α ×ₗ β) :=
   ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_lt b; exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_min_order_of_right Prod.Lex.noMinOrder_of_right

448144f7

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -105,33 +105,20 @@ instance preorder (α β : Type _) [Preorder α] [Preorder β] : Preorder (α ×
         constructor
         · rintro (⟨_, _, hlt⟩ | ⟨_, hlt⟩)
           · constructor
-            · left
-              assumption
+            · left; assumption
             · rintro ⟨⟩
-              · apply lt_asymm hlt
-                assumption
+              · apply lt_asymm hlt; assumption
               · apply lt_irrefl _ hlt
           · constructor
-            · right
-              rw [lt_iff_le_not_le] at hlt
-              exact hlt.1
+            · right; rw [lt_iff_le_not_le] at hlt; exact hlt.1
             · rintro ⟨⟩
-              · apply lt_irrefl a₁
-                assumption
-              · rw [lt_iff_le_not_le] at hlt
-                apply hlt.2
-                assumption
+              · apply lt_irrefl a₁; assumption
+              · rw [lt_iff_le_not_le] at hlt; apply hlt.2; assumption
         · rintro ⟨⟨⟩, h₂r⟩
-          · left
-            assumption
-          · right
-            rw [lt_iff_le_not_le]
-            constructor
+          · left; assumption
+          · right; rw [lt_iff_le_not_le]; constructor
             · assumption
-            · intro h
-              apply h₂r
-              right
-              exact h }
+            · intro h; apply h₂r; right; exact h }
 #align prod.lex.preorder Prod.Lex.preorder
 -/
 
@@ -245,10 +232,7 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
 Case conversion may be inaccurate. Consider using '#align prod.lex.no_max_order_of_left Prod.Lex.noMaxOrder_of_leftₓ'. -/
 instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α ×ₗ β) :=
-  ⟨by
-    rintro ⟨a, b⟩
-    obtain ⟨c, h⟩ := exists_gt a
-    exact ⟨⟨c, b⟩, left _ _ h⟩⟩
+  ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_gt a; exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_max_order_of_left Prod.Lex.noMaxOrder_of_left
 
 /- warning: prod.lex.no_min_order_of_left -> Prod.Lex.noMinOrder_of_left is a dubious translation:
@@ -258,10 +242,7 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
 Case conversion may be inaccurate. Consider using '#align prod.lex.no_min_order_of_left Prod.Lex.noMinOrder_of_leftₓ'. -/
 instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α ×ₗ β) :=
-  ⟨by
-    rintro ⟨a, b⟩
-    obtain ⟨c, h⟩ := exists_lt a
-    exact ⟨⟨c, b⟩, left _ _ h⟩⟩
+  ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_lt a; exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_min_order_of_left Prod.Lex.noMinOrder_of_left
 
 /- warning: prod.lex.no_max_order_of_right -> Prod.Lex.noMaxOrder_of_right is a dubious translation:
@@ -271,10 +252,7 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u2} β (Preorder.toLT.{u2} β _inst_2)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
 Case conversion may be inaccurate. Consider using '#align prod.lex.no_max_order_of_right Prod.Lex.noMaxOrder_of_rightₓ'. -/
 instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α ×ₗ β) :=
-  ⟨by
-    rintro ⟨a, b⟩
-    obtain ⟨c, h⟩ := exists_gt b
-    exact ⟨⟨a, c⟩, right _ h⟩⟩
+  ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_gt b; exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_max_order_of_right Prod.Lex.noMaxOrder_of_right
 
 /- warning: prod.lex.no_min_order_of_right -> Prod.Lex.noMinOrder_of_right is a dubious translation:
@@ -284,10 +262,7 @@ but is expected to have type
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u2} β (Preorder.toLT.{u2} β _inst_2)], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
 Case conversion may be inaccurate. Consider using '#align prod.lex.no_min_order_of_right Prod.Lex.noMinOrder_of_rightₓ'. -/
 instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α ×ₗ β) :=
-  ⟨by
-    rintro ⟨a, b⟩
-    obtain ⟨c, h⟩ := exists_lt b
-    exact ⟨⟨a, c⟩, right _ h⟩⟩
+  ⟨by rintro ⟨a, b⟩; obtain ⟨c, h⟩ := exists_lt b; exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_min_order_of_right Prod.Lex.noMinOrder_of_right
 
 end Prod.Lex

448144f7

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -74,7 +74,7 @@ instance instLT (α β : Type _) [LT α] [LT β] : LT (α ×ₗ β) where lt :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : LE.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β _inst_1 _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) b)) (Or (LT.lt.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (And (Eq.{succ u1} α (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (LE.le.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LE.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLE.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LE.le.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LE.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLE.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LE.le.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
 Case conversion may be inaccurate. Consider using '#align prod.lex.le_iff Prod.Lex.le_iffₓ'. -/
 theorem le_iff [LT α] [LE β] (a b : α × β) :
     toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2 :=
@@ -85,7 +85,7 @@ theorem le_iff [LT α] [LE β] (a b : α × β) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : LT.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β _inst_1 _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) b)) (Or (LT.lt.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (And (Eq.{succ u1} α (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (LT.lt.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LT.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLT.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LT.lt.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LT.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLT.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LT.lt.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
 Case conversion may be inaccurate. Consider using '#align prod.lex.lt_iff Prod.Lex.lt_iffₓ'. -/
 theorem lt_iff [LT α] [LT β] (a b : α × β) :
     toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2 :=
@@ -143,7 +143,7 @@ variable [PartialOrder α] [Preorder β]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β], Monotone.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (Prod.Lex.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], Monotone.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], Monotone.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
 Case conversion may be inaccurate. Consider using '#align prod.lex.to_lex_mono Prod.Lex.toLex_monoₓ'. -/
 theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
   by
@@ -157,7 +157,7 @@ theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β], StrictMono.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (Prod.Lex.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], StrictMono.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], StrictMono.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.812 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
 Case conversion may be inaccurate. Consider using '#align prod.lex.to_lex_strict_mono Prod.Lex.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) :=
   by

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -194,28 +194,40 @@ instance linearOrder (α β : Type _) [LinearOrder α] [LinearOrder β] : Linear
 #align prod.lex.linear_order Prod.Lex.linearOrder
 -/
 
-#print Prod.Lex.orderBot /-
+/- warning: prod.lex.order_bot -> Prod.Lex.orderBot is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2)], OrderBot.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toHasLe.{u2} β _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderBot.{u2} β (Preorder.toLE.{u2} β _inst_2)], OrderBot.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u2} β _inst_2))
+Case conversion may be inaccurate. Consider using '#align prod.lex.order_bot Prod.Lex.orderBotₓ'. -/
 instance orderBot [PartialOrder α] [Preorder β] [OrderBot α] [OrderBot β] : OrderBot (α ×ₗ β)
     where
   bot := toLex ⊥
   bot_le a := toLex_mono bot_le
 #align prod.lex.order_bot Prod.Lex.orderBot
--/
 
-#print Prod.Lex.orderTop /-
+/- warning: prod.lex.order_top -> Prod.Lex.orderTop is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2)], OrderTop.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toHasLe.{u2} β _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : OrderTop.{u2} β (Preorder.toLE.{u2} β _inst_2)], OrderTop.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u2} β _inst_2))
+Case conversion may be inaccurate. Consider using '#align prod.lex.order_top Prod.Lex.orderTopₓ'. -/
 instance orderTop [PartialOrder α] [Preorder β] [OrderTop α] [OrderTop β] : OrderTop (α ×ₗ β)
     where
   top := toLex ⊤
   le_top a := toLex_mono le_top
 #align prod.lex.order_top Prod.Lex.orderTop
--/
 
-#print Prod.Lex.boundedOrder /-
+/- warning: prod.lex.bounded_order -> Prod.Lex.boundedOrder is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : BoundedOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : BoundedOrder.{u2} β (Preorder.toHasLe.{u2} β _inst_2)], BoundedOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toHasLe.{u2} β _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : BoundedOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : BoundedOrder.{u2} β (Preorder.toLE.{u2} β _inst_2)], BoundedOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Preorder.toLE.{u2} β _inst_2))
+Case conversion may be inaccurate. Consider using '#align prod.lex.bounded_order Prod.Lex.boundedOrderₓ'. -/
 instance boundedOrder [PartialOrder α] [Preorder β] [BoundedOrder α] [BoundedOrder β] :
     BoundedOrder (α ×ₗ β) :=
   { Lex.orderBot, Lex.orderTop with }
 #align prod.lex.bounded_order Prod.Lex.boundedOrder
--/
 
 instance [Preorder α] [Preorder β] [DenselyOrdered α] [DenselyOrdered β] :
     DenselyOrdered (α ×ₗ β) :=
@@ -226,41 +238,57 @@ instance [Preorder α] [Preorder β] [DenselyOrdered α] [DenselyOrdered β] :
     · obtain ⟨c, h₁, h₂⟩ := exists_between h
       exact ⟨(a, c), right _ h₁, right _ h₂⟩⟩
 
-#print Prod.Lex.noMaxOrder_of_left /-
+/- warning: prod.lex.no_max_order_of_left -> Prod.Lex.noMaxOrder_of_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
+Case conversion may be inaccurate. Consider using '#align prod.lex.no_max_order_of_left Prod.Lex.noMaxOrder_of_leftₓ'. -/
 instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α ×ₗ β) :=
   ⟨by
     rintro ⟨a, b⟩
     obtain ⟨c, h⟩ := exists_gt a
     exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_max_order_of_left Prod.Lex.noMaxOrder_of_left
--/
 
-#print Prod.Lex.noMinOrder_of_left /-
+/- warning: prod.lex.no_min_order_of_left -> Prod.Lex.noMinOrder_of_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], NoMinOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
+Case conversion may be inaccurate. Consider using '#align prod.lex.no_min_order_of_left Prod.Lex.noMinOrder_of_leftₓ'. -/
 instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α ×ₗ β) :=
   ⟨by
     rintro ⟨a, b⟩
     obtain ⟨c, h⟩ := exists_lt a
     exact ⟨⟨c, b⟩, left _ _ h⟩⟩
 #align prod.lex.no_min_order_of_left Prod.Lex.noMinOrder_of_left
--/
 
-#print Prod.Lex.noMaxOrder_of_right /-
+/- warning: prod.lex.no_max_order_of_right -> Prod.Lex.noMaxOrder_of_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u2} β (Preorder.toHasLt.{u2} β _inst_2)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMaxOrder.{u2} β (Preorder.toLT.{u2} β _inst_2)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
+Case conversion may be inaccurate. Consider using '#align prod.lex.no_max_order_of_right Prod.Lex.noMaxOrder_of_rightₓ'. -/
 instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α ×ₗ β) :=
   ⟨by
     rintro ⟨a, b⟩
     obtain ⟨c, h⟩ := exists_gt b
     exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_max_order_of_right Prod.Lex.noMaxOrder_of_right
--/
 
-#print Prod.Lex.noMinOrder_of_right /-
+/- warning: prod.lex.no_min_order_of_right -> Prod.Lex.noMinOrder_of_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u2} β (Preorder.toHasLt.{u2} β _inst_2)], NoMinOrder.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toHasLt.{u1} α _inst_1) (Preorder.toHasLt.{u2} β _inst_2))
+but is expected to have type
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] [_inst_3 : NoMinOrder.{u2} β (Preorder.toLT.{u2} β _inst_2)], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β (Preorder.toLT.{u1} α _inst_1) (Preorder.toLT.{u2} β _inst_2))
+Case conversion may be inaccurate. Consider using '#align prod.lex.no_min_order_of_right Prod.Lex.noMinOrder_of_rightₓ'. -/
 instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α ×ₗ β) :=
   ⟨by
     rintro ⟨a, b⟩
     obtain ⟨c, h⟩ := exists_lt b
     exact ⟨⟨a, c⟩, right _ h⟩⟩
 #align prod.lex.no_min_order_of_right Prod.Lex.noMinOrder_of_right
--/
 
 end Prod.Lex

448144f7

bump to nightly-2023-03-11-22

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

a8ee822f

Diff

@@ -74,7 +74,7 @@ instance instLT (α β : Type _) [LT α] [LT β] : LT (α ×ₗ β) where lt :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : LE.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLE.{u1, u2} α β _inst_1 _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) b)) (Or (LT.lt.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (And (Eq.{succ u1} α (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (LE.le.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LE.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLE.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LE.le.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LE.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LE.le.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLE.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LE.le.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
 Case conversion may be inaccurate. Consider using '#align prod.lex.le_iff Prod.Lex.le_iffₓ'. -/
 theorem le_iff [LT α] [LE β] (a b : α × β) :
     toLex a ≤ toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 ≤ b.2 :=
@@ -85,7 +85,7 @@ theorem le_iff [LT α] [LE β] (a b : α × β) :
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : LT.{u1} α] [_inst_2 : LT.{u2} β] (a : Prod.{u1, u2} α β) (b : Prod.{u1, u2} α β), Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.Lex.instLT.{u1, u2} α β _inst_1 _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) a) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)) b)) (Or (LT.lt.{u1} α _inst_1 (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (And (Eq.{succ u1} α (Prod.fst.{u1, u2} α β a) (Prod.fst.{u1, u2} α β b)) (LT.lt.{u2} β _inst_2 (Prod.snd.{u1, u2} α β a) (Prod.snd.{u1, u2} α β b))))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LT.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLT.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LT.lt.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : LT.{u2} α] [_inst_2 : LT.{u1} β] (a : Prod.{u2, u1} α β) (b : Prod.{u2, u1} α β), Iff (LT.lt.{max u2 u1} ((fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) a) (Prod.Lex.instLT.{u2, u1} α β _inst_1 _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) a) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)) b)) (Or (LT.lt.{u2} α _inst_1 (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (And (Eq.{succ u2} α (Prod.fst.{u2, u1} α β a) (Prod.fst.{u2, u1} α β b)) (LT.lt.{u1} β _inst_2 (Prod.snd.{u2, u1} α β a) (Prod.snd.{u2, u1} α β b))))
 Case conversion may be inaccurate. Consider using '#align prod.lex.lt_iff Prod.Lex.lt_iffₓ'. -/
 theorem lt_iff [LT α] [LT β] (a b : α × β) :
     toLex a < toLex b ↔ a.1 < b.1 ∨ a.1 = b.1 ∧ a.2 < b.2 :=
@@ -143,7 +143,7 @@ variable [PartialOrder α] [Preorder β]
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β], Monotone.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (Prod.Lex.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], Monotone.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], Monotone.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
 Case conversion may be inaccurate. Consider using '#align prod.lex.to_lex_mono Prod.Lex.toLex_monoₓ'. -/
 theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
   by
@@ -157,7 +157,7 @@ theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) :=
 lean 3 declaration is
   forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : Preorder.{u2} β], StrictMono.{max u1 u2, max u1 u2} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β)) (Prod.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (Prod.Lex.preorder.{u1, u2} α β (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (coeFn.{succ (max u1 u2), succ (max u1 u2)} (Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (fun (_x : Equiv.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) => (Prod.{u1, u2} α β) -> (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (Equiv.hasCoeToFun.{succ (max u1 u2), succ (max u1 u2)} (Prod.{u1, u2} α β) (Lex.{max u1 u2} (Prod.{u1, u2} α β))) (toLex.{max u1 u2} (Prod.{u1, u2} α β)))
 but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], StrictMono.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.805 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
+  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : Preorder.{u1} β], StrictMono.{max u2 u1, max u2 u1} (Prod.{u2, u1} α β) (Lex.{max u1 u2} (Prod.{u2, u1} α β)) (Prod.instPreorderProd.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (Prod.Lex.preorder.{u2, u1} α β (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2) (FunLike.coe.{succ (max u2 u1), succ (max u2 u1), succ (max u2 u1)} (Equiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (Prod.{u2, u1} α β) (fun (_x : Prod.{u2, u1} α β) => (fun (x._@.Mathlib.Logic.Equiv.Defs._hyg.808 : Prod.{u2, u1} α β) => Lex.{max u2 u1} (Prod.{u2, u1} α β)) _x) (Equiv.instFunLikeEquiv.{succ (max u2 u1), succ (max u2 u1)} (Prod.{u2, u1} α β) (Lex.{max u2 u1} (Prod.{u2, u1} α β))) (toLex.{max u2 u1} (Prod.{u2, u1} α β)))
 Case conversion may be inaccurate. Consider using '#align prod.lex.to_lex_strict_mono Prod.Lex.toLex_strictMonoₓ'. -/
 theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) :=
   by

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

70d50ecf

style: homogenise porting notes (#11145)

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

converts "--porting note" into "-- Porting note";
converts "porting note" into "Porting note".

8be0b69c

Diff

@@ -35,7 +35,7 @@ variable {α β γ : Type*}
 
 namespace Prod.Lex
 
--- porting note: `Prod.Lex` is not protected in core, hence the `_root_.` prefix
+-- Porting note: `Prod.Lex` is not protected in core, hence the `_root_.` prefix
 -- This will be fixed in nightly-2022-11-30
 @[inherit_doc] notation:35 α " ×ₗ " β:34 => _root_.Lex (Prod α β)

70d50ecf

chore: remove workarounds for lean4#1891 (#9290)

We no longer need to explicitly specify the Monotone and StrictMono arguments, after https://github.com/leanprover/lean4/commit/069873d8e5e0e7bed18f71edb63d18da50748ec9 fixed https://github.com/leanprover/lean4/issues/1891.

Compare to the mathlib3 declarations: https://github.com/leanprover-community/mathlib/blob/65a1391a0106c9204fe45bc73a039f056558cb83/src/data/prod/lex.lean#L93-L107

9757df4e

Diff

@@ -108,22 +108,14 @@ section Preorder
 
 variable [PartialOrder α] [Preorder β]
 
--- porting note: type class search sees right through the type synonrm for `α ×ₗ β` and uses the
--- `Preorder` structure for `α × β` instead
--- This is hopefully the same problems as in https://github.com/leanprover/lean4/issues/1891
--- and will be fixed in nightly-2022-11-30
-theorem toLex_mono : @Monotone _ _ _ (Prod.Lex.preorder α β) (toLex : α × β → α ×ₗ β) := by
+theorem toLex_mono : Monotone (toLex : α × β → α ×ₗ β) := by
   rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ ⟨ha, hb⟩
   obtain rfl | ha : a₁ = a₂ ∨ _ := ha.eq_or_lt
   · exact right _ hb
   · exact left _ _ ha
 #align prod.lex.to_lex_mono Prod.Lex.toLex_mono
 
--- porting note: type class search sees right through the type synonrm for `α ×ₗ β` and uses the
--- `Preorder` structure for `α × β` instead
--- This is hopefully the same problems as in https://github.com/leanprover/lean4/issues/1891
--- and will be fixed in nightly-2022-11-30
-theorem toLex_strictMono : @StrictMono _ _ _ (Prod.Lex.preorder α β) (toLex : α × β → α ×ₗ β) := by
+theorem toLex_strictMono : StrictMono (toLex : α × β → α ×ₗ β) := by
   rintro ⟨a₁, b₁⟩ ⟨a₂, b₂⟩ h
   obtain rfl | ha : a₁ = a₂ ∨ _ := h.le.1.eq_or_lt
   · exact right _ (Prod.mk_lt_mk_iff_right.1 h)

70d50ecf

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

@@ -31,7 +31,7 @@ Related files are:
 -/
 
 
-variable {α β γ : Type _}
+variable {α β γ : Type*}
 
 namespace Prod.Lex
 
@@ -39,19 +39,19 @@ namespace Prod.Lex
 -- This will be fixed in nightly-2022-11-30
 @[inherit_doc] notation:35 α " ×ₗ " β:34 => _root_.Lex (Prod α β)
 
-instance decidableEq (α β : Type _) [DecidableEq α] [DecidableEq β] : DecidableEq (α ×ₗ β) :=
+instance decidableEq (α β : Type*) [DecidableEq α] [DecidableEq β] : DecidableEq (α ×ₗ β) :=
   instDecidableEqProd
 #align prod.lex.decidable_eq Prod.Lex.decidableEq
 
-instance inhabited (α β : Type _) [Inhabited α] [Inhabited β] : Inhabited (α ×ₗ β) :=
+instance inhabited (α β : Type*) [Inhabited α] [Inhabited β] : Inhabited (α ×ₗ β) :=
   instInhabitedProd
 #align prod.lex.inhabited Prod.Lex.inhabited
 
 /-- Dictionary / lexicographic ordering on pairs.  -/
-instance instLE (α β : Type _) [LT α] [LE β] : LE (α ×ₗ β) where le := Prod.Lex (· < ·) (· ≤ ·)
+instance instLE (α β : Type*) [LT α] [LE β] : LE (α ×ₗ β) where le := Prod.Lex (· < ·) (· ≤ ·)
 #align prod.lex.has_le Prod.Lex.instLE
 
-instance instLT (α β : Type _) [LT α] [LT β] : LT (α ×ₗ β) where lt := Prod.Lex (· < ·) (· < ·)
+instance instLT (α β : Type*) [LT α] [LT β] : LT (α ×ₗ β) where lt := Prod.Lex (· < ·) (· < ·)
 #align prod.lex.has_lt Prod.Lex.instLT
 
 theorem le_iff [LT α] [LE β] (a b : α × β) :
@@ -67,7 +67,7 @@ theorem lt_iff [LT α] [LT β] (a b : α × β) :
 example (x : α) (y : β) : toLex (x, y) = toLex (x, y) := rfl
 
 /-- Dictionary / lexicographic preorder for pairs. -/
-instance preorder (α β : Type _) [Preorder α] [Preorder β] : Preorder (α ×ₗ β) :=
+instance preorder (α β : Type*) [Preorder α] [Preorder β] : Preorder (α ×ₗ β) :=
   { Prod.Lex.instLE α β, Prod.Lex.instLT α β with
     le_refl := refl_of <| Prod.Lex _ _,
     le_trans := fun _ _ _ => trans_of <| Prod.Lex _ _,
@@ -133,7 +133,7 @@ theorem toLex_strictMono : @StrictMono _ _ _ (Prod.Lex.preorder α β) (toLex :
 end Preorder
 
 /-- Dictionary / lexicographic partial order for pairs. -/
-instance partialOrder (α β : Type _) [PartialOrder α] [PartialOrder β] : PartialOrder (α ×ₗ β) :=
+instance partialOrder (α β : Type*) [PartialOrder α] [PartialOrder β] : PartialOrder (α ×ₗ β) :=
   { Prod.Lex.preorder α β with
     le_antisymm := by
       haveI : IsStrictOrder α (· < ·) := { irrefl := lt_irrefl, trans := fun _ _ _ => lt_trans }
@@ -142,7 +142,7 @@ instance partialOrder (α β : Type _) [PartialOrder α] [PartialOrder β] : Par
 #align prod.lex.partial_order Prod.Lex.partialOrder
 
 /-- Dictionary / lexicographic linear order for pairs. -/
-instance linearOrder (α β : Type _) [LinearOrder α] [LinearOrder β] : LinearOrder (α ×ₗ β) :=
+instance linearOrder (α β : Type*) [LinearOrder α] [LinearOrder β] : LinearOrder (α ×ₗ β) :=
   { Prod.Lex.partialOrder α β with
     le_total := total_of (Prod.Lex _ _),
     decidableLE := Prod.Lex.decidable _ _,

70d50ecf

chore: Ord instance for Prod.Lex (#6090)

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

c8f191da

Diff

@@ -150,6 +150,9 @@ instance linearOrder (α β : Type _) [LinearOrder α] [LinearOrder β] : Linear
     decidableEq := Lex.decidableEq _ _, }
 #align prod.lex.linear_order Prod.Lex.linearOrder
 
+instance [Ord α] [Ord β] : Ord (α ×ₗ β) where
+  compare := compareLex (compareOn (·.1)) (compareOn (·.2))
+
 instance orderBot [PartialOrder α] [Preorder β] [OrderBot α] [OrderBot β] : OrderBot (α ×ₗ β) where
   bot := toLex ⊥
   bot_le _ := toLex_mono bot_le

70d50ecf

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,14 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Minchao Wu
-
-! This file was ported from Lean 3 source module data.prod.lex
-! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.BoundedOrder
 
+#align_import data.prod.lex from "leanprover-community/mathlib"@"70d50ecfd4900dd6d328da39ab7ebd516abe4025"
+
 /-!
 # Lexicographic order

70d50ecf

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

@@ -148,9 +148,9 @@ instance partialOrder (α β : Type _) [PartialOrder α] [PartialOrder β] : Par
 instance linearOrder (α β : Type _) [LinearOrder α] [LinearOrder β] : LinearOrder (α ×ₗ β) :=
   { Prod.Lex.partialOrder α β with
     le_total := total_of (Prod.Lex _ _),
-    decidable_le := Prod.Lex.decidable _ _,
-    decidable_lt := Prod.Lex.decidable _ _,
-    decidable_eq := Lex.decidableEq _ _, }
+    decidableLE := Prod.Lex.decidable _ _,
+    decidableLT := Prod.Lex.decidable _ _,
+    decidableEq := Lex.decidableEq _ _, }
 #align prod.lex.linear_order Prod.Lex.linearOrder
 
 instance orderBot [PartialOrder α] [Preorder β] [OrderBot α] [OrderBot β] : OrderBot (α ×ₗ β) where

70d50ecf

chore: fix #align lines (#3640)

This PR fixes two things:

Most align statements for definitions and theorems and instances that are separated by two newlines from the relevant declaration (s/\n\n#align/\n#align). This is often seen in the mathport output after ending calc blocks.
All remaining more-than-one-line #align statements. (This was needed for a script I wrote for #3630.)

2b42dc7c

Diff

@@ -131,7 +131,6 @@ theorem toLex_strictMono : @StrictMono _ _ _ (Prod.Lex.preorder α β) (toLex :
   obtain rfl | ha : a₁ = a₂ ∨ _ := h.le.1.eq_or_lt
   · exact right _ (Prod.mk_lt_mk_iff_right.1 h)
   · exact left _ _ ha
-
 #align prod.lex.to_lex_strict_mono Prod.Lex.toLex_strictMono
 
 end Preorder

70d50ecf

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

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

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2019 Scott Morrison. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Scott Morrison, Minchao Wu
+
+! This file was ported from Lean 3 source module data.prod.lex
+! leanprover-community/mathlib commit 70d50ecfd4900dd6d328da39ab7ebd516abe4025
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Order.BoundedOrder

`data.prod.lex` ⟷ `Mathlib.Data.Prod.Lex`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 23

data.prod.lex ⟷ Mathlib.Data.Prod.Lex

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 23

`data.prod.lex` ⟷ `Mathlib.Data.Prod.Lex`