data.sigma.order | 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

1fc36cc9

(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

@@ -122,7 +122,7 @@ instance [∀ i, Preorder (α i)] : Preorder (Σ i, α i) :=
       · rintro ⟨i, a, b, hab⟩
         rwa [mk_le_mk_iff, mk_le_mk_iff, ← lt_iff_le_not_le]
       · rintro ⟨⟨i, a, b, hab⟩, h⟩
-        rw [mk_le_mk_iff] at h 
+        rw [mk_le_mk_iff] at h
         exact mk_lt_mk_iff.2 (hab.lt_of_not_le h) }
 
 instance [∀ i, PartialOrder (α i)] : PartialOrder (Σ i, α i) :=

448144f7

bump to nightly-2023-09-24-06

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

5655435f

Diff

@@ -3,8 +3,8 @@ Copyright (c) 2021 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Data.Sigma.Lex
-import Mathbin.Order.BoundedOrder
+import Data.Sigma.Lex
+import Order.BoundedOrder
 
 #align_import data.sigma.order 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,15 +2,12 @@
 Copyright (c) 2021 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module data.sigma.order
-! 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.Data.Sigma.Lex
 import Mathbin.Order.BoundedOrder
 
+#align_import data.sigma.order from "leanprover-community/mathlib"@"448144f7ae193a8990cb7473c9e9a01990f64ac7"
+
 /-!
 # Orders on a sigma type

448144f7

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -145,7 +145,6 @@ instance [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)] : DenselyOrdere
 
 namespace Lex
 
--- mathport name: «exprΣₗ , »
 notation3"Σₗ "(...)", "r:(scoped p => Lex Sigma p) => r
 
 #print Sigma.Lex.LE /-
@@ -162,15 +161,19 @@ instance LT [LT ι] [∀ i, LT (α i)] : LT (Σₗ i, α i) :=
 #align sigma.lex.has_lt Sigma.Lex.LT
 -/
 
+#print Sigma.Lex.le_def /-
 theorem le_def [LT ι] [∀ i, LE (α i)] {a b : Σₗ i, α i} :
     a ≤ b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 :=
   Sigma.lex_iff
 #align sigma.lex.le_def Sigma.Lex.le_def
+-/
 
+#print Sigma.Lex.lt_def /-
 theorem lt_def [LT ι] [∀ i, LT (α i)] {a b : Σₗ i, α i} :
     a < b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 < b.2 :=
   Sigma.lex_iff
 #align sigma.lex.lt_def Sigma.Lex.lt_def
+-/
 
 #print Sigma.Lex.preorder /-
 /-- The lexicographical preorder on a sigma type. -/
@@ -209,6 +212,7 @@ instance linearOrder [LinearOrder ι] [∀ i, LinearOrder (α i)] : LinearOrder
 #align sigma.lex.linear_order Sigma.Lex.linearOrder
 -/
 
+#print Sigma.Lex.orderBot /-
 /-- The lexicographical linear order on a sigma type. -/
 instance orderBot [PartialOrder ι] [OrderBot ι] [∀ i, Preorder (α i)] [OrderBot (α ⊥)] :
     OrderBot (Σₗ i, α i) where
@@ -218,7 +222,9 @@ instance orderBot [PartialOrder ι] [OrderBot ι] [∀ i, Preorder (α i)] [Orde
     · exact lex.right _ _ bot_le
     · exact lex.left _ _ ha
 #align sigma.lex.order_bot Sigma.Lex.orderBot
+-/
 
+#print Sigma.Lex.orderTop /-
 /-- The lexicographical linear order on a sigma type. -/
 instance orderTop [PartialOrder ι] [OrderTop ι] [∀ i, Preorder (α i)] [OrderTop (α ⊤)] :
     OrderTop (Σₗ i, α i) where
@@ -228,12 +234,15 @@ instance orderTop [PartialOrder ι] [OrderTop ι] [∀ i, Preorder (α i)] [Orde
     · exact lex.right _ _ le_top
     · exact lex.left _ _ ha
 #align sigma.lex.order_top Sigma.Lex.orderTop
+-/
 
+#print Sigma.Lex.boundedOrder /-
 /-- The lexicographical linear order on a sigma type. -/
 instance boundedOrder [PartialOrder ι] [BoundedOrder ι] [∀ i, Preorder (α i)] [OrderBot (α ⊥)]
     [OrderTop (α ⊤)] : BoundedOrder (Σₗ i, α i) :=
   { Lex.orderBot, Lex.orderTop with }
 #align sigma.lex.bounded_order Sigma.Lex.boundedOrder
+-/
 
 #print Sigma.Lex.denselyOrdered /-
 instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i)] [∀ i, Preorder (α i)]

448144f7

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -55,22 +55,22 @@ variable {ι : Type _} {α : ι → Type _}
 
 #print Sigma.le /-
 /-- Disjoint sum of orders. `⟨i, a⟩ ≤ ⟨j, b⟩` iff `i = j` and `a ≤ b`. -/
-inductive le [∀ i, LE (α i)] : ∀ a b : Σi, α i, Prop
+inductive le [∀ i, LE (α i)] : ∀ a b : Σ i, α i, Prop
   | fiber (i : ι) (a b : α i) : a ≤ b → le ⟨i, a⟩ ⟨i, b⟩
 #align sigma.le Sigma.le
 -/
 
 #print Sigma.lt /-
 /-- Disjoint sum of orders. `⟨i, a⟩ < ⟨j, b⟩` iff `i = j` and `a < b`. -/
-inductive lt [∀ i, LT (α i)] : ∀ a b : Σi, α i, Prop
+inductive lt [∀ i, LT (α i)] : ∀ a b : Σ i, α i, Prop
   | fiber (i : ι) (a b : α i) : a < b → lt ⟨i, a⟩ ⟨i, b⟩
 #align sigma.lt Sigma.lt
 -/
 
-instance [∀ i, LE (α i)] : LE (Σi, α i) :=
+instance [∀ i, LE (α i)] : LE (Σ i, α i) :=
   ⟨le⟩
 
-instance [∀ i, LT (α i)] : LT (Σi, α i) :=
+instance [∀ i, LT (α i)] : LT (Σ i, α i) :=
   ⟨lt⟩
 
 #print Sigma.mk_le_mk_iff /-
@@ -88,7 +88,7 @@ theorem mk_lt_mk_iff [∀ i, LT (α i)] {i : ι} {a b : α i} : (⟨i, a⟩ : Si
 -/
 
 #print Sigma.le_def /-
-theorem le_def [∀ i, LE (α i)] {a b : Σi, α i} : a ≤ b ↔ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 :=
+theorem le_def [∀ i, LE (α i)] {a b : Σ i, α i} : a ≤ b ↔ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 :=
   by
   constructor
   · rintro ⟨i, a, b, h⟩
@@ -101,7 +101,7 @@ theorem le_def [∀ i, LE (α i)] {a b : Σi, α i} : a ≤ b ↔ ∃ h : a.1 =
 -/
 
 #print Sigma.lt_def /-
-theorem lt_def [∀ i, LT (α i)] {a b : Σi, α i} : a < b ↔ ∃ h : a.1 = b.1, h.rec a.2 < b.2 :=
+theorem lt_def [∀ i, LT (α i)] {a b : Σ i, α i} : a < b ↔ ∃ h : a.1 = b.1, h.rec a.2 < b.2 :=
   by
   constructor
   · rintro ⟨i, a, b, h⟩
@@ -113,7 +113,7 @@ theorem lt_def [∀ i, LT (α i)] {a b : Σi, α i} : a < b ↔ ∃ h : a.1 = b.
 #align sigma.lt_def Sigma.lt_def
 -/
 
-instance [∀ i, Preorder (α i)] : Preorder (Σi, α i) :=
+instance [∀ i, Preorder (α i)] : Preorder (Σ i, α i) :=
   { Sigma.hasLe,
     Sigma.hasLt with
     le_refl := fun ⟨i, a⟩ => le.fiber i a a le_rfl
@@ -125,16 +125,16 @@ instance [∀ i, Preorder (α i)] : Preorder (Σi, α i) :=
       · rintro ⟨i, a, b, hab⟩
         rwa [mk_le_mk_iff, mk_le_mk_iff, ← lt_iff_le_not_le]
       · rintro ⟨⟨i, a, b, hab⟩, h⟩
-        rw [mk_le_mk_iff] at h
+        rw [mk_le_mk_iff] at h 
         exact mk_lt_mk_iff.2 (hab.lt_of_not_le h) }
 
-instance [∀ i, PartialOrder (α i)] : PartialOrder (Σi, α i) :=
+instance [∀ i, PartialOrder (α i)] : PartialOrder (Σ i, α i) :=
   { Sigma.preorder with
     le_antisymm := by
       rintro _ _ ⟨i, a, b, hab⟩ ⟨_, _, _, hba⟩
       exact ext rfl (hEq_of_eq <| hab.antisymm hba) }
 
-instance [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)] : DenselyOrdered (Σi, α i) :=
+instance [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)] : DenselyOrdered (Σ i, α i) :=
   ⟨by
     rintro ⟨i, a⟩ ⟨_, _⟩ ⟨_, _, b, h⟩
     obtain ⟨c, ha, hb⟩ := exists_between h

448144f7

bump to nightly-2023-06-01-04

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

4d9eaa85

Diff

@@ -283,16 +283,14 @@ instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrd
 #align sigma.lex.no_max_order_of_nonempty Sigma.Lex.noMaxOrder_of_nonempty
 -/
 
-/- warning: sigma.lex.no_min_order_of_nonempty clashes with [anonymous] -> [anonymous]
-Case conversion may be inaccurate. Consider using '#align sigma.lex.no_min_order_of_nonempty [anonymous]ₓ'. -/
-instance [anonymous] [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι] [∀ i, Nonempty (α i)] :
-    NoMaxOrder (Σₗ i, α i) :=
+instance no_min_order_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι]
+    [∀ i, Nonempty (α i)] : NoMaxOrder (Σₗ i, α i) :=
   ⟨by
     rintro ⟨i, a⟩
     obtain ⟨j, h⟩ := exists_gt i
     obtain ⟨b⟩ : Nonempty (α j) := inferInstance
     exact ⟨⟨j, b⟩, left _ _ h⟩⟩
-#align sigma.lex.no_min_order_of_nonempty [anonymous]
+#align sigma.lex.no_min_order_of_nonempty Sigma.Lex.no_min_order_of_nonempty
 
 #print Sigma.Lex.noMaxOrder /-
 instance noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMaxOrder (α i)] :

448144f7

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -235,6 +235,7 @@ instance boundedOrder [PartialOrder ι] [BoundedOrder ι] [∀ i, Preorder (α i
   { Lex.orderBot, Lex.orderTop with }
 #align sigma.lex.bounded_order Sigma.Lex.boundedOrder
 
+#print Sigma.Lex.denselyOrdered /-
 instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i)] [∀ i, Preorder (α i)]
     [∀ i, DenselyOrdered (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -245,7 +246,9 @@ instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i
     · obtain ⟨c, ha, hb⟩ := exists_between h
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered Sigma.Lex.denselyOrdered
+-/
 
+#print Sigma.Lex.denselyOrdered_of_noMaxOrder /-
 instance denselyOrdered_of_noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)]
     [∀ i, NoMaxOrder (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -255,7 +258,9 @@ instance denselyOrdered_of_noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [
     · obtain ⟨c, ha, hb⟩ := exists_between h
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered_of_no_max_order Sigma.Lex.denselyOrdered_of_noMaxOrder
+-/
 
+#print Sigma.Lex.denselyOrdered_of_noMinOrder /-
 instance denselyOrdered_of_noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)]
     [∀ i, NoMinOrder (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -265,7 +270,9 @@ instance denselyOrdered_of_noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [
     · obtain ⟨c, ha, hb⟩ := exists_between h
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered_of_no_min_order Sigma.Lex.denselyOrdered_of_noMinOrder
+-/
 
+#print Sigma.Lex.noMaxOrder_of_nonempty /-
 instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι]
     [∀ i, Nonempty (α i)] : NoMaxOrder (Σₗ i, α i) :=
   ⟨by
@@ -274,6 +281,7 @@ instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrd
     obtain ⟨b⟩ : Nonempty (α j) := inferInstance
     exact ⟨⟨j, b⟩, left _ _ h⟩⟩
 #align sigma.lex.no_max_order_of_nonempty Sigma.Lex.noMaxOrder_of_nonempty
+-/
 
 /- warning: sigma.lex.no_min_order_of_nonempty clashes with [anonymous] -> [anonymous]
 Case conversion may be inaccurate. Consider using '#align sigma.lex.no_min_order_of_nonempty [anonymous]ₓ'. -/
@@ -286,15 +294,19 @@ instance [anonymous] [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι] [∀
     exact ⟨⟨j, b⟩, left _ _ h⟩⟩
 #align sigma.lex.no_min_order_of_nonempty [anonymous]
 
+#print Sigma.Lex.noMaxOrder /-
 instance noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMaxOrder (α i)] :
     NoMaxOrder (Σₗ i, α i) :=
   ⟨by rintro ⟨i, a⟩; obtain ⟨b, h⟩ := exists_gt a; exact ⟨⟨i, b⟩, right _ _ h⟩⟩
 #align sigma.lex.no_max_order Sigma.Lex.noMaxOrder
+-/
 
+#print Sigma.Lex.noMinOrder /-
 instance noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMinOrder (α i)] :
     NoMinOrder (Σₗ i, α i) :=
   ⟨by rintro ⟨i, a⟩; obtain ⟨b, h⟩ := exists_lt a; exact ⟨⟨i, b⟩, right _ _ h⟩⟩
 #align sigma.lex.no_min_order Sigma.Lex.noMinOrder
+-/
 
 end Lex

448144f7

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -162,23 +162,11 @@ instance LT [LT ι] [∀ i, LT (α i)] : LT (Σₗ i, α i) :=
 #align sigma.lex.has_lt Sigma.Lex.LT
 -/
 
-/- warning: sigma.lex.le_def -> Sigma.Lex.le_def is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : forall (i : ι), LE.{u2} (α i)] {a : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u1} ι _inst_1 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) => LE.le.{u2} (α (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Eq.ndrec.{succ u2, succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) α (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) b))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : LT.{u2} ι] [_inst_2 : forall (i : ι), LE.{u1} (α i)] {a : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))}, Iff (LE.le.{max u2 u1} (Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u2, u1} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u2} ι _inst_1 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) => LE.le.{u1} (α (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Eq.rec.{succ u1, succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (fun (x._@.Mathlib.Data.Sigma.Order._hyg.1527 : ι) (x._@.Mathlib.Data.Sigma.Order._hyg.1526 : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) x._@.Mathlib.Data.Sigma.Order._hyg.1527) => α x._@.Mathlib.Data.Sigma.Order._hyg.1527) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) b))))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.le_def Sigma.Lex.le_defₓ'. -/
 theorem le_def [LT ι] [∀ i, LE (α i)] {a b : Σₗ i, α i} :
     a ≤ b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 :=
   Sigma.lex_iff
 #align sigma.lex.le_def Sigma.Lex.le_def
 
-/- warning: sigma.lex.lt_def -> Sigma.Lex.lt_def is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : forall (i : ι), LT.{u2} (α i)] {a : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u1} ι _inst_1 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) => LT.lt.{u2} (α (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Eq.ndrec.{succ u2, succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) α (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) b))))
-but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : LT.{u2} ι] [_inst_2 : forall (i : ι), LT.{u1} (α i)] {a : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))}, Iff (LT.lt.{max u2 u1} (Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u2, u1} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u2} ι _inst_1 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) => LT.lt.{u1} (α (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Eq.rec.{succ u1, succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (fun (x._@.Mathlib.Data.Sigma.Order._hyg.1627 : ι) (x._@.Mathlib.Data.Sigma.Order._hyg.1626 : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) x._@.Mathlib.Data.Sigma.Order._hyg.1627) => α x._@.Mathlib.Data.Sigma.Order._hyg.1627) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) b))))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.lt_def Sigma.Lex.lt_defₓ'. -/
 theorem lt_def [LT ι] [∀ i, LT (α i)] {a b : Σₗ i, α i} :
     a < b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 < b.2 :=
   Sigma.lex_iff
@@ -221,12 +209,6 @@ instance linearOrder [LinearOrder ι] [∀ i, LinearOrder (α i)] : LinearOrder
 #align sigma.lex.linear_order Sigma.Lex.linearOrder
 -/
 
-/- warning: sigma.lex.order_bot -> Sigma.Lex.orderBot is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toHasLe.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderBot.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toHasLe.{u2} (α i) (_inst_3 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toLE.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderBot.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.order_bot Sigma.Lex.orderBotₓ'. -/
 /-- The lexicographical linear order on a sigma type. -/
 instance orderBot [PartialOrder ι] [OrderBot ι] [∀ i, Preorder (α i)] [OrderBot (α ⊥)] :
     OrderBot (Σₗ i, α i) where
@@ -237,12 +219,6 @@ instance orderBot [PartialOrder ι] [OrderBot ι] [∀ i, Preorder (α i)] [Orde
     · exact lex.left _ _ ha
 #align sigma.lex.order_bot Sigma.Lex.orderBot
 
-/- warning: sigma.lex.order_top -> Sigma.Lex.orderTop is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toHasLe.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderTop.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toHasLe.{u2} (α i) (_inst_3 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toLE.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderTop.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.order_top Sigma.Lex.orderTopₓ'. -/
 /-- The lexicographical linear order on a sigma type. -/
 instance orderTop [PartialOrder ι] [OrderTop ι] [∀ i, Preorder (α i)] [OrderTop (α ⊤)] :
     OrderTop (Σₗ i, α i) where
@@ -253,24 +229,12 @@ instance orderTop [PartialOrder ι] [OrderTop ι] [∀ i, Preorder (α i)] [Orde
     · exact lex.left _ _ ha
 #align sigma.lex.order_top Sigma.Lex.orderTop
 
-/- warning: sigma.lex.bounded_order -> Sigma.Lex.boundedOrder is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : BoundedOrder.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toHasLe.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))] [_inst_5 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toHasLe.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))], BoundedOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toHasLe.{u2} (α i) (_inst_3 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : BoundedOrder.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toLE.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))] [_inst_5 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toLE.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))], BoundedOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.bounded_order Sigma.Lex.boundedOrderₓ'. -/
 /-- The lexicographical linear order on a sigma type. -/
 instance boundedOrder [PartialOrder ι] [BoundedOrder ι] [∀ i, Preorder (α i)] [OrderBot (α ⊥)]
     [OrderTop (α ⊤)] : BoundedOrder (Σₗ i, α i) :=
   { Lex.orderBot, Lex.orderTop with }
 #align sigma.lex.bounded_order Sigma.Lex.boundedOrder
 
-/- warning: sigma.lex.densely_ordered -> Sigma.Lex.denselyOrdered is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DenselyOrdered.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1)] [_inst_3 : forall (i : ι), Nonempty.{succ u2} (α i)] [_inst_4 : forall (i : ι), Preorder.{u2} (α i)] [_inst_5 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_4 i))], DenselyOrdered.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_4 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DenselyOrdered.{u1} ι (Preorder.toLT.{u1} ι _inst_1)] [_inst_3 : forall (i : ι), Nonempty.{succ u2} (α i)] [_inst_4 : forall (i : ι), Preorder.{u2} (α i)] [_inst_5 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_4 i))], DenselyOrdered.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_4 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.densely_ordered Sigma.Lex.denselyOrderedₓ'. -/
 instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i)] [∀ i, Preorder (α i)]
     [∀ i, DenselyOrdered (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -282,12 +246,6 @@ instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered Sigma.Lex.denselyOrdered
 
-/- warning: sigma.lex.densely_ordered_of_no_max_order -> Sigma.Lex.denselyOrdered_of_noMaxOrder is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.densely_ordered_of_no_max_order Sigma.Lex.denselyOrdered_of_noMaxOrderₓ'. -/
 instance denselyOrdered_of_noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)]
     [∀ i, NoMaxOrder (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -298,12 +256,6 @@ instance denselyOrdered_of_noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered_of_no_max_order Sigma.Lex.denselyOrdered_of_noMaxOrder
 
-/- warning: sigma.lex.densely_ordered_of_no_min_order -> Sigma.Lex.denselyOrdered_of_noMinOrder is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.densely_ordered_of_no_min_order Sigma.Lex.denselyOrdered_of_noMinOrderₓ'. -/
 instance denselyOrdered_of_noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)]
     [∀ i, NoMinOrder (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -314,12 +266,6 @@ instance denselyOrdered_of_noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered_of_no_min_order Sigma.Lex.denselyOrdered_of_noMinOrder
 
-/- warning: sigma.lex.no_max_order_of_nonempty -> Sigma.Lex.noMaxOrder_of_nonempty is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : NoMaxOrder.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1)] [_inst_4 : forall (i : ι), Nonempty.{succ u2} (α i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : NoMaxOrder.{u1} ι (Preorder.toLT.{u1} ι _inst_1)] [_inst_4 : forall (i : ι), Nonempty.{succ u2} (α i)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.no_max_order_of_nonempty Sigma.Lex.noMaxOrder_of_nonemptyₓ'. -/
 instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι]
     [∀ i, Nonempty (α i)] : NoMaxOrder (Σₗ i, α i) :=
   ⟨by
@@ -330,11 +276,6 @@ instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrd
 #align sigma.lex.no_max_order_of_nonempty Sigma.Lex.noMaxOrder_of_nonempty
 
 /- warning: sigma.lex.no_min_order_of_nonempty clashes with [anonymous] -> [anonymous]
-warning: sigma.lex.no_min_order_of_nonempty -> [anonymous] is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : NoMaxOrder.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1)] [_inst_4 : forall (i : ι), Nonempty.{succ u2} (α i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : Type.{u2}}, (Nat -> ι -> α) -> Nat -> (List.{u1} ι) -> (List.{u2} α)
 Case conversion may be inaccurate. Consider using '#align sigma.lex.no_min_order_of_nonempty [anonymous]ₓ'. -/
 instance [anonymous] [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι] [∀ i, Nonempty (α i)] :
     NoMaxOrder (Σₗ i, α i) :=
@@ -345,23 +286,11 @@ instance [anonymous] [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι] [∀
     exact ⟨⟨j, b⟩, left _ _ h⟩⟩
 #align sigma.lex.no_min_order_of_nonempty [anonymous]
 
-/- warning: sigma.lex.no_max_order -> Sigma.Lex.noMaxOrder is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.no_max_order Sigma.Lex.noMaxOrderₓ'. -/
 instance noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMaxOrder (α i)] :
     NoMaxOrder (Σₗ i, α i) :=
   ⟨by rintro ⟨i, a⟩; obtain ⟨b, h⟩ := exists_gt a; exact ⟨⟨i, b⟩, right _ _ h⟩⟩
 #align sigma.lex.no_max_order Sigma.Lex.noMaxOrder
 
-/- warning: sigma.lex.no_min_order -> Sigma.Lex.noMinOrder is a dubious translation:
-lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], NoMinOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
-but is expected to have type
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
-Case conversion may be inaccurate. Consider using '#align sigma.lex.no_min_order Sigma.Lex.noMinOrderₓ'. -/
 instance noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMinOrder (α i)] :
     NoMinOrder (Σₗ i, α i) :=
   ⟨by rintro ⟨i, a⟩; obtain ⟨b, h⟩ := exists_lt a; exact ⟨⟨i, b⟩, right _ _ h⟩⟩

448144f7

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -353,10 +353,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align sigma.lex.no_max_order Sigma.Lex.noMaxOrderₓ'. -/
 instance noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMaxOrder (α i)] :
     NoMaxOrder (Σₗ i, α i) :=
-  ⟨by
-    rintro ⟨i, a⟩
-    obtain ⟨b, h⟩ := exists_gt a
-    exact ⟨⟨i, b⟩, right _ _ h⟩⟩
+  ⟨by rintro ⟨i, a⟩; obtain ⟨b, h⟩ := exists_gt a; exact ⟨⟨i, b⟩, right _ _ h⟩⟩
 #align sigma.lex.no_max_order Sigma.Lex.noMaxOrder
 
 /- warning: sigma.lex.no_min_order -> Sigma.Lex.noMinOrder is a dubious translation:
@@ -367,10 +364,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align sigma.lex.no_min_order Sigma.Lex.noMinOrderₓ'. -/
 instance noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMinOrder (α i)] :
     NoMinOrder (Σₗ i, α i) :=
-  ⟨by
-    rintro ⟨i, a⟩
-    obtain ⟨b, h⟩ := exists_lt a
-    exact ⟨⟨i, b⟩, right _ _ h⟩⟩
+  ⟨by rintro ⟨i, a⟩; obtain ⟨b, h⟩ := exists_lt a; exact ⟨⟨i, b⟩, right _ _ h⟩⟩
 #align sigma.lex.no_min_order Sigma.Lex.noMinOrder
 
 end Lex

448144f7

bump to nightly-2023-05-19-16

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

a31df521

Diff

@@ -166,7 +166,7 @@ instance LT [LT ι] [∀ i, LT (α i)] : LT (Σₗ i, α i) :=
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : forall (i : ι), LE.{u2} (α i)] {a : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))}, Iff (LE.le.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u1} ι _inst_1 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) => LE.le.{u2} (α (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Eq.ndrec.{succ u2, succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) α (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) b))))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : LT.{u2} ι] [_inst_2 : forall (i : ι), LE.{u1} (α i)] {a : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))}, Iff (LE.le.{max u2 u1} (Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u2, u1} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u2} ι _inst_1 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) => LE.le.{u1} (α (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Eq.rec.{succ u1, succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (fun (x._@.Mathlib.Data.Sigma.Order._hyg.1523 : ι) (x._@.Mathlib.Data.Sigma.Order._hyg.1522 : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) x._@.Mathlib.Data.Sigma.Order._hyg.1523) => α x._@.Mathlib.Data.Sigma.Order._hyg.1523) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) b))))
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : LT.{u2} ι] [_inst_2 : forall (i : ι), LE.{u1} (α i)] {a : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))}, Iff (LE.le.{max u2 u1} (Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u2, u1} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u2} ι _inst_1 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) => LE.le.{u1} (α (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Eq.rec.{succ u1, succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (fun (x._@.Mathlib.Data.Sigma.Order._hyg.1527 : ι) (x._@.Mathlib.Data.Sigma.Order._hyg.1526 : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) x._@.Mathlib.Data.Sigma.Order._hyg.1527) => α x._@.Mathlib.Data.Sigma.Order._hyg.1527) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) b))))
 Case conversion may be inaccurate. Consider using '#align sigma.lex.le_def Sigma.Lex.le_defₓ'. -/
 theorem le_def [LT ι] [∀ i, LE (α i)] {a b : Σₗ i, α i} :
     a ≤ b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 ≤ b.2 :=
@@ -177,7 +177,7 @@ theorem le_def [LT ι] [∀ i, LE (α i)] {a b : Σₗ i, α i} :
 lean 3 declaration is
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : LT.{u1} ι] [_inst_2 : forall (i : ι), LT.{u2} (α i)] {a : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))}, Iff (LT.lt.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u1} ι _inst_1 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) => LT.lt.{u2} (α (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b)) (Eq.ndrec.{succ u2, succ u1} ι (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) a) α (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) a) (Sigma.fst.{u1, u2} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u1, u2} ι (fun (i : ι) => α i) b))))
 but is expected to have type
-  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : LT.{u2} ι] [_inst_2 : forall (i : ι), LT.{u1} (α i)] {a : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))}, Iff (LT.lt.{max u2 u1} (Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u2, u1} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u2} ι _inst_1 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) => LT.lt.{u1} (α (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Eq.rec.{succ u1, succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (fun (x._@.Mathlib.Data.Sigma.Order._hyg.1623 : ι) (x._@.Mathlib.Data.Sigma.Order._hyg.1622 : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) x._@.Mathlib.Data.Sigma.Order._hyg.1623) => α x._@.Mathlib.Data.Sigma.Order._hyg.1623) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) b))))
+  forall {ι : Type.{u2}} {α : ι -> Type.{u1}} [_inst_1 : LT.{u2} ι] [_inst_2 : forall (i : ι), LT.{u1} (α i)] {a : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))} {b : Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))}, Iff (LT.lt.{max u2 u1} (Lex.{max u1 u2} (Sigma.{u2, u1} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u2, u1} ι (fun (i : ι) => α i) _inst_1 (fun (i : ι) => _inst_2 i)) a b) (Or (LT.lt.{u2} ι _inst_1 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Exists.{0} (Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (fun (h : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) => LT.lt.{u1} (α (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (_inst_2 (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b)) (Eq.rec.{succ u1, succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) (fun (x._@.Mathlib.Data.Sigma.Order._hyg.1627 : ι) (x._@.Mathlib.Data.Sigma.Order._hyg.1626 : Eq.{succ u2} ι (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) a) x._@.Mathlib.Data.Sigma.Order._hyg.1627) => α x._@.Mathlib.Data.Sigma.Order._hyg.1627) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) a) (Sigma.fst.{u2, u1} ι (fun (i : ι) => α i) b) h) (Sigma.snd.{u2, u1} ι (fun (i : ι) => α i) b))))
 Case conversion may be inaccurate. Consider using '#align sigma.lex.lt_def Sigma.Lex.lt_defₓ'. -/
 theorem lt_def [LT ι] [∀ i, LT (α i)] {a b : Σₗ i, α i} :
     a < b ↔ a.1 < b.1 ∨ ∃ h : a.1 = b.1, h.rec a.2 < b.2 :=

448144f7

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -223,7 +223,7 @@ instance linearOrder [LinearOrder ι] [∀ i, LinearOrder (α i)] : LinearOrder
 
 /- warning: sigma.lex.order_bot -> Sigma.Lex.orderBot is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toLE.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderBot.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toHasLe.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderBot.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toHasLe.{u2} (α i) (_inst_3 i)))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toLE.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderBot.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
 Case conversion may be inaccurate. Consider using '#align sigma.lex.order_bot Sigma.Lex.orderBotₓ'. -/
@@ -239,7 +239,7 @@ instance orderBot [PartialOrder ι] [OrderBot ι] [∀ i, Preorder (α i)] [Orde
 
 /- warning: sigma.lex.order_top -> Sigma.Lex.orderTop is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toLE.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderTop.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toHasLe.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderTop.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toHasLe.{u2} (α i) (_inst_3 i)))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : OrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (Preorder.toLE.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))) (_inst_3 (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2))))], OrderTop.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
 Case conversion may be inaccurate. Consider using '#align sigma.lex.order_top Sigma.Lex.orderTopₓ'. -/
@@ -255,7 +255,7 @@ instance orderTop [PartialOrder ι] [OrderTop ι] [∀ i, Preorder (α i)] [Orde
 
 /- warning: sigma.lex.bounded_order -> Sigma.Lex.boundedOrder is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : BoundedOrder.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toLE.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))] [_inst_5 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toLE.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))], BoundedOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : BoundedOrder.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toHasLe.{u2} (α (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toHasBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))] [_inst_5 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toHasLe.{u2} (α (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Top.top.{u1} ι (OrderTop.toHasTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toHasLe.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))], BoundedOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toHasLe.{u2} (α i) (_inst_3 i)))
 but is expected to have type
   forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : PartialOrder.{u1} ι] [_inst_2 : BoundedOrder.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1))] [_inst_3 : forall (i : ι), Preorder.{u2} (α i)] [_inst_4 : OrderBot.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toLE.{u2} (α (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Bot.bot.{u1} ι (OrderBot.toBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderBot.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))] [_inst_5 : OrderTop.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (Preorder.toLE.{u2} (α (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))) (_inst_3 (Top.top.{u1} ι (OrderTop.toTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (BoundedOrder.toOrderTop.{u1} ι (Preorder.toLE.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) _inst_2)))))], BoundedOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LE.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι (PartialOrder.toPreorder.{u1} ι _inst_1)) (fun (i : ι) => Preorder.toLE.{u2} (α i) (_inst_3 i)))
 Case conversion may be inaccurate. Consider using '#align sigma.lex.bounded_order Sigma.Lex.boundedOrderₓ'. -/
@@ -265,7 +265,12 @@ instance boundedOrder [PartialOrder ι] [BoundedOrder ι] [∀ i, Preorder (α i
   { Lex.orderBot, Lex.orderTop with }
 #align sigma.lex.bounded_order Sigma.Lex.boundedOrder
 
-#print Sigma.Lex.denselyOrdered /-
+/- warning: sigma.lex.densely_ordered -> Sigma.Lex.denselyOrdered is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DenselyOrdered.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1)] [_inst_3 : forall (i : ι), Nonempty.{succ u2} (α i)] [_inst_4 : forall (i : ι), Preorder.{u2} (α i)] [_inst_5 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_4 i))], DenselyOrdered.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_4 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : DenselyOrdered.{u1} ι (Preorder.toLT.{u1} ι _inst_1)] [_inst_3 : forall (i : ι), Nonempty.{succ u2} (α i)] [_inst_4 : forall (i : ι), Preorder.{u2} (α i)] [_inst_5 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_4 i))], DenselyOrdered.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_4 i)))
+Case conversion may be inaccurate. Consider using '#align sigma.lex.densely_ordered Sigma.Lex.denselyOrderedₓ'. -/
 instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i)] [∀ i, Preorder (α i)]
     [∀ i, DenselyOrdered (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -276,9 +281,13 @@ instance denselyOrdered [Preorder ι] [DenselyOrdered ι] [∀ i, Nonempty (α i
     · obtain ⟨c, ha, hb⟩ := exists_between h
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered Sigma.Lex.denselyOrdered
--/
 
-#print Sigma.Lex.denselyOrdered_of_noMaxOrder /-
+/- warning: sigma.lex.densely_ordered_of_no_max_order -> Sigma.Lex.denselyOrdered_of_noMaxOrder is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
+Case conversion may be inaccurate. Consider using '#align sigma.lex.densely_ordered_of_no_max_order Sigma.Lex.denselyOrdered_of_noMaxOrderₓ'. -/
 instance denselyOrdered_of_noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)]
     [∀ i, NoMaxOrder (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -288,9 +297,13 @@ instance denselyOrdered_of_noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [
     · obtain ⟨c, ha, hb⟩ := exists_between h
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered_of_no_max_order Sigma.Lex.denselyOrdered_of_noMaxOrder
--/
 
-#print Sigma.Lex.denselyOrdered_of_noMinOrder /-
+/- warning: sigma.lex.densely_ordered_of_no_min_order -> Sigma.Lex.denselyOrdered_of_noMinOrder is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), DenselyOrdered.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))] [_inst_4 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], DenselyOrdered.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
+Case conversion may be inaccurate. Consider using '#align sigma.lex.densely_ordered_of_no_min_order Sigma.Lex.denselyOrdered_of_noMinOrderₓ'. -/
 instance denselyOrdered_of_noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)]
     [∀ i, NoMinOrder (α i)] : DenselyOrdered (Σₗ i, α i) :=
   ⟨by
@@ -300,9 +313,13 @@ instance denselyOrdered_of_noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [
     · obtain ⟨c, ha, hb⟩ := exists_between h
       exact ⟨⟨i, c⟩, right _ _ ha, right _ _ hb⟩⟩
 #align sigma.lex.densely_ordered_of_no_min_order Sigma.Lex.denselyOrdered_of_noMinOrder
--/
 
-#print Sigma.Lex.noMaxOrder_of_nonempty /-
+/- warning: sigma.lex.no_max_order_of_nonempty -> Sigma.Lex.noMaxOrder_of_nonempty is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : NoMaxOrder.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1)] [_inst_4 : forall (i : ι), Nonempty.{succ u2} (α i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : NoMaxOrder.{u1} ι (Preorder.toLT.{u1} ι _inst_1)] [_inst_4 : forall (i : ι), Nonempty.{succ u2} (α i)], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
+Case conversion may be inaccurate. Consider using '#align sigma.lex.no_max_order_of_nonempty Sigma.Lex.noMaxOrder_of_nonemptyₓ'. -/
 instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι]
     [∀ i, Nonempty (α i)] : NoMaxOrder (Σₗ i, α i) :=
   ⟨by
@@ -311,12 +328,11 @@ instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrd
     obtain ⟨b⟩ : Nonempty (α j) := inferInstance
     exact ⟨⟨j, b⟩, left _ _ h⟩⟩
 #align sigma.lex.no_max_order_of_nonempty Sigma.Lex.noMaxOrder_of_nonempty
--/
 
 /- warning: sigma.lex.no_min_order_of_nonempty clashes with [anonymous] -> [anonymous]
 warning: sigma.lex.no_min_order_of_nonempty -> [anonymous] is a dubious translation:
 lean 3 declaration is
-  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : NoMaxOrder.{u1} ι (Preorder.toLT.{u1} ι _inst_1)] [_inst_4 : forall (i : ι), Nonempty.{succ u2} (α i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : NoMaxOrder.{u1} ι (Preorder.toHasLt.{u1} ι _inst_1)] [_inst_4 : forall (i : ι), Nonempty.{succ u2} (α i)], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
 but is expected to have type
   forall {ι : Type.{u1}} {α : Type.{u2}}, (Nat -> ι -> α) -> Nat -> (List.{u1} ι) -> (List.{u2} α)
 Case conversion may be inaccurate. Consider using '#align sigma.lex.no_min_order_of_nonempty [anonymous]ₓ'. -/
@@ -329,7 +345,12 @@ instance [anonymous] [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrder ι] [∀
     exact ⟨⟨j, b⟩, left _ _ h⟩⟩
 #align sigma.lex.no_min_order_of_nonempty [anonymous]
 
-#print Sigma.Lex.noMaxOrder /-
+/- warning: sigma.lex.no_max_order -> Sigma.Lex.noMaxOrder is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], NoMaxOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMaxOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], NoMaxOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
+Case conversion may be inaccurate. Consider using '#align sigma.lex.no_max_order Sigma.Lex.noMaxOrderₓ'. -/
 instance noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMaxOrder (α i)] :
     NoMaxOrder (Σₗ i, α i) :=
   ⟨by
@@ -337,9 +358,13 @@ instance noMaxOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMaxOrder (
     obtain ⟨b, h⟩ := exists_gt a
     exact ⟨⟨i, b⟩, right _ _ h⟩⟩
 #align sigma.lex.no_max_order Sigma.Lex.noMaxOrder
--/
 
-#print Sigma.Lex.noMinOrder /-
+/- warning: sigma.lex.no_min_order -> Sigma.Lex.noMinOrder is a dubious translation:
+lean 3 declaration is
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toHasLt.{u2} (α i) (_inst_2 i))], NoMinOrder.{max u1 u2} (Lex.{max u1 u2} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toHasLt.{u1} ι _inst_1) (fun (i : ι) => Preorder.toHasLt.{u2} (α i) (_inst_2 i)))
+but is expected to have type
+  forall {ι : Type.{u1}} {α : ι -> Type.{u2}} [_inst_1 : Preorder.{u1} ι] [_inst_2 : forall (i : ι), Preorder.{u2} (α i)] [_inst_3 : forall (i : ι), NoMinOrder.{u2} (α i) (Preorder.toLT.{u2} (α i) (_inst_2 i))], NoMinOrder.{max u2 u1} (Lex.{max u2 u1} (Sigma.{u1, u2} ι (fun (i : ι) => α i))) (Sigma.Lex.LT.{u1, u2} ι (fun (i : ι) => α i) (Preorder.toLT.{u1} ι _inst_1) (fun (i : ι) => Preorder.toLT.{u2} (α i) (_inst_2 i)))
+Case conversion may be inaccurate. Consider using '#align sigma.lex.no_min_order Sigma.Lex.noMinOrderₓ'. -/
 instance noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMinOrder (α i)] :
     NoMinOrder (Σₗ i, α i) :=
   ⟨by
@@ -347,7 +372,6 @@ instance noMinOrder [Preorder ι] [∀ i, Preorder (α i)] [∀ i, NoMinOrder (
     obtain ⟨b, h⟩ := exists_lt a
     exact ⟨⟨i, b⟩, right _ _ h⟩⟩
 #align sigma.lex.no_min_order Sigma.Lex.noMinOrder
--/
 
 end Lex

448144f7

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

1fc36cc9

chore: remove mathport name: <expression> lines (#11928)

Quoting [@digama0](https://github.com/digama0):

These were actually never meant to go in the file, they are basically debugging information and only useful on significantly broken mathport files. You can safely remove all of them.

11431c65

Diff

@@ -126,7 +126,6 @@ instance [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)] : DenselyOrdere
 
 
 namespace Lex
--- mathport name: «exprΣₗ , »
 /-- The notation `Σₗ i, α i` refers to a sigma type equipped with the lexicographic order. -/
 notation3 "Σₗ "(...)", "r:(scoped p => _root_.Lex (Sigma p)) => r

1fc36cc9

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

@@ -49,7 +49,7 @@ variable {ι : Type*} {α : ι → Type*}
 
 /-! ### Disjoint sum of orders on `Sigma` -/
 
--- porting note: I made this `le` instead of `LE` because the output type is `Prop`
+-- Porting note: I made this `le` instead of `LE` because the output type is `Prop`
 /-- Disjoint sum of orders. `⟨i, a⟩ ≤ ⟨j, b⟩` iff `i = j` and `a ≤ b`. -/
 protected inductive le [∀ i, LE (α i)] : ∀ _a _b : Σ i, α i, Prop
   | fiber (i : ι) (a b : α i) : a ≤ b → Sigma.le ⟨i, a⟩ ⟨i, b⟩
@@ -253,7 +253,7 @@ instance noMaxOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMaxOrd
     exact ⟨⟨j, b⟩, left _ _ h⟩
 #align sigma.lex.no_max_order_of_nonempty Sigma.Lex.noMaxOrder_of_nonempty
 
--- porting note: this statement was incorrect in mathlib3, hence the `#noalign`.
+-- Porting note: this statement was incorrect in mathlib3, hence the `#noalign`.
 instance noMinOrder_of_nonempty [Preorder ι] [∀ i, Preorder (α i)] [NoMinOrder ι]
     [∀ i, Nonempty (α i)] : NoMinOrder (Σₗ i, α i) where
   exists_lt := by

1fc36cc9

chore: reduce imports (#9830)

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

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

f4c4ca61

Diff

@@ -6,6 +6,7 @@ Authors: Yaël Dillies
 import Mathlib.Data.Sigma.Lex
 import Mathlib.Order.BoundedOrder
 import Mathlib.Mathport.Notation
+import Mathlib.Data.Sigma.Basic
 
 #align_import data.sigma.order from "leanprover-community/mathlib"@"1fc36cc9c8264e6e81253f88be7fb2cb6c92d76a"

1fc36cc9

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

@@ -44,7 +44,7 @@ Upgrade `Equiv.sigma_congr_left`, `Equiv.sigma_congr`, `Equiv.sigma_assoc`,
 
 namespace Sigma
 
-variable {ι : Type _} {α : ι → Type _}
+variable {ι : Type*} {α : ι → Type*}
 
 /-! ### Disjoint sum of orders on `Sigma` -/

1fc36cc9

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module data.sigma.order
-! leanprover-community/mathlib commit 1fc36cc9c8264e6e81253f88be7fb2cb6c92d76a
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Sigma.Lex
 import Mathlib.Order.BoundedOrder
 import Mathlib.Mathport.Notation
 
+#align_import data.sigma.order from "leanprover-community/mathlib"@"1fc36cc9c8264e6e81253f88be7fb2cb6c92d76a"
+
 /-!
 # Orders on a sigma type

1fc36cc9

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

@@ -183,8 +183,8 @@ instance linearOrder [LinearOrder ι] [∀ i, LinearOrder (α i)] :
     LinearOrder (Σₗ i, α i) :=
   { Lex.partialOrder with
     le_total := total_of ((Lex (· < ·)) fun _ => (· ≤ ·)),
-    decidable_eq := Sigma.instDecidableEqSigma,
-    decidable_le := Lex.decidable _ _ }
+    decidableEq := Sigma.instDecidableEqSigma,
+    decidableLE := Lex.decidable _ _ }
 #align sigma.lex.linear_order Sigma.Lex.linearOrder
 
 /-- The lexicographical linear order on a sigma type. -/

1fc36cc9

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

@@ -195,7 +195,6 @@ instance orderBot [PartialOrder ι] [OrderBot ι] [∀ i, Preorder (α i)] [Orde
     obtain rfl | ha := eq_bot_or_bot_lt a
     · exact Lex.right _ _ bot_le
     · exact Lex.left _ _ ha
-
 #align sigma.lex.order_bot Sigma.Lex.orderBot
 
 /-- The lexicographical linear order on a sigma type. -/
@@ -206,7 +205,6 @@ instance orderTop [PartialOrder ι] [OrderTop ι] [∀ i, Preorder (α i)] [Orde
     obtain rfl | ha := eq_top_or_lt_top a
     · exact Lex.right _ _ le_top
     · exact Lex.left _ _ ha
-
 #align sigma.lex.order_top Sigma.Lex.orderTop
 
 /-- The lexicographical linear order on a sigma type. -/

1fc36cc9

chore: fix casing per naming scheme (#1183)

Fix a lot of wrong casing mostly in the docstrings but also sometimes in def/theorem names. E.g. fin 2 --> Fin 2, add_monoid_hom --> AddMonoidHom

Remove \n from to_additive docstrings that were inserted by mathport.

Move files and directories with Gcd and Smul to GCD and SMul

71723d8b

Diff

@@ -49,7 +49,7 @@ namespace Sigma
 
 variable {ι : Type _} {α : ι → Type _}
 
-/-! ### Disjoint sum of orders on `sigma` -/
+/-! ### Disjoint sum of orders on `Sigma` -/
 
 -- porting note: I made this `le` instead of `LE` because the output type is `Prop`
 /-- Disjoint sum of orders. `⟨i, a⟩ ≤ ⟨j, b⟩` iff `i = j` and `a ≤ b`. -/
@@ -124,7 +124,7 @@ instance [∀ i, Preorder (α i)] [∀ i, DenselyOrdered (α i)] : DenselyOrdere
     obtain ⟨c, ha, hb⟩ := exists_between h
     exact ⟨⟨i, c⟩, lt.fiber i a c ha, lt.fiber i c b hb⟩
 
-/-! ### Lexicographical order on `sigma` -/
+/-! ### Lexicographical order on `Sigma` -/
 
 
 namespace Lex

1fc36cc9

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) 2021 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
+
+! This file was ported from Lean 3 source module data.sigma.order
+! leanprover-community/mathlib commit 1fc36cc9c8264e6e81253f88be7fb2cb6c92d76a
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Data.Sigma.Lex
 import Mathlib.Order.BoundedOrder

`data.sigma.order` ⟷ `Mathlib.Data.Sigma.Order`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 25

data.sigma.order ⟷ Mathlib.Data.Sigma.Order

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 25

`data.sigma.order` ⟷ `Mathlib.Data.Sigma.Order`