order.max | Mathlib porting status

Changes since the initial port

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

Changes in mathlib3

6623e6af

(last sync)

fix(*): add missing classical tactics and decidable arguments (#18277)

As discussed in this Zulip thread, the classical tactic is buggy in Mathlib3, and "leaks" into subsequent declarations.

This doesn't port well, as the bug is fixed in lean 4.

This PR installs a temporary hack to contain these leaks, fixes all of the correponding breakages, then reverts the hack.

The result is that the new classical tactics in the diff are not needed in Lean 3, but will be needed in Lean 4.

In a future PR, I will try committing the hack itself; but in the meantime, these files are very close to (if not beyond) the port, so the sooner they are fixed the better.

Diff

@@ -95,6 +95,7 @@ end⟩
 
 instance [nonempty ι] [Π i, preorder (π i)] [Π i, no_min_order (π i)] : no_min_order (Π i, π i) :=
 ⟨λ a, begin
+  classical,
   obtain ⟨b, hb⟩ := exists_lt (a $ classical.arbitrary _),
   exact ⟨_, update_lt_self_iff.2 hb⟩,
 end⟩

c4658a64

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

6623e6af

bump to nightly-2024-02-01-06

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

5433bded

Diff

@@ -135,10 +135,16 @@ instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMin
 -/
 
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] : NoMaxOrder (∀ i, π i) :=
-  ⟨fun a => by classical⟩
+  ⟨fun a => by
+    classical
+    obtain ⟨b, hb⟩ := exists_gt (a <| Classical.arbitrary _)
+    exact ⟨_, lt_update_self_iff.2 hb⟩⟩
 
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMinOrder (π i)] : NoMinOrder (∀ i, π i) :=
-  ⟨fun a => by classical⟩
+  ⟨fun a => by
+    classical
+    obtain ⟨b, hb⟩ := exists_lt (a <| Classical.arbitrary _)
+    exact ⟨_, update_lt_self_iff.2 hb⟩⟩
 
 -- See note [lower instance priority]
 instance (priority := 100) NoMinOrder.to_noBotOrder (α : Type _) [Preorder α] [NoMinOrder α] :

6623e6af

bump to nightly-2024-01-31-06

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

61100fe9

Diff

@@ -135,16 +135,10 @@ instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMin
 -/
 
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] : NoMaxOrder (∀ i, π i) :=
-  ⟨fun a => by
-    classical
-    obtain ⟨b, hb⟩ := exists_gt (a <| Classical.arbitrary _)
-    exact ⟨_, lt_update_self_iff.2 hb⟩⟩
+  ⟨fun a => by classical⟩
 
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMinOrder (π i)] : NoMinOrder (∀ i, π i) :=
-  ⟨fun a => by
-    classical
-    obtain ⟨b, hb⟩ := exists_lt (a <| Classical.arbitrary _)
-    exact ⟨_, update_lt_self_iff.2 hb⟩⟩
+  ⟨fun a => by classical⟩
 
 -- See note [lower instance priority]
 instance (priority := 100) NoMinOrder.to_noBotOrder (α : Type _) [Preorder α] [NoMinOrder α] :

6623e6af

bump to nightly-2023-10-21-06

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

a2dc86f8

Diff

@@ -421,14 +421,14 @@ theorem isMax_iff_forall_not_lt : IsMax a ↔ ∀ b, ¬a < b :=
 #print not_isMin_iff /-
 @[simp]
 theorem not_isMin_iff : ¬IsMin a ↔ ∃ b, b < a := by
-  simp_rw [lt_iff_le_not_le, IsMin, not_forall, exists_prop]
+  simp_rw [lt_iff_le_not_le, IsMin, Classical.not_forall, exists_prop]
 #align not_is_min_iff not_isMin_iff
 -/
 
 #print not_isMax_iff /-
 @[simp]
 theorem not_isMax_iff : ¬IsMax a ↔ ∃ b, a < b := by
-  simp_rw [lt_iff_le_not_le, IsMax, not_forall, exists_prop]
+  simp_rw [lt_iff_le_not_le, IsMax, Classical.not_forall, exists_prop]
 #align not_is_max_iff not_isMax_iff
 -/

6623e6af

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) 2014 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Yury Kudryashov, Yaël Dillies
 -/
-import Mathbin.Order.Synonym
+import Order.Synonym
 
 #align_import order.max from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"

6623e6af

bump to nightly-2023-08-23-23

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

f612b9e0

Diff

@@ -328,28 +328,28 @@ theorem isMax_ofDual_iff {a : αᵒᵈ} : IsMax (ofDual a) ↔ IsMin a :=
 #align is_max_of_dual_iff isMax_ofDual_iff
 -/
 
-alias isBot_toDual_iff ↔ _ IsTop.toDual
+alias ⟨_, IsTop.toDual⟩ := isBot_toDual_iff
 #align is_top.to_dual IsTop.toDual
 
-alias isTop_toDual_iff ↔ _ IsBot.toDual
+alias ⟨_, IsBot.toDual⟩ := isTop_toDual_iff
 #align is_bot.to_dual IsBot.toDual
 
-alias isMin_toDual_iff ↔ _ IsMax.toDual
+alias ⟨_, IsMax.toDual⟩ := isMin_toDual_iff
 #align is_max.to_dual IsMax.toDual
 
-alias isMax_toDual_iff ↔ _ IsMin.toDual
+alias ⟨_, IsMin.toDual⟩ := isMax_toDual_iff
 #align is_min.to_dual IsMin.toDual
 
-alias isBot_ofDual_iff ↔ _ IsTop.ofDual
+alias ⟨_, IsTop.ofDual⟩ := isBot_ofDual_iff
 #align is_top.of_dual IsTop.ofDual
 
-alias isTop_ofDual_iff ↔ _ IsBot.ofDual
+alias ⟨_, IsBot.ofDual⟩ := isTop_ofDual_iff
 #align is_bot.of_dual IsBot.ofDual
 
-alias isMin_ofDual_iff ↔ _ IsMax.ofDual
+alias ⟨_, IsMax.ofDual⟩ := isMin_ofDual_iff
 #align is_max.of_dual IsMax.ofDual
 
-alias isMax_ofDual_iff ↔ _ IsMin.ofDual
+alias ⟨_, IsMin.ofDual⟩ := isMax_ofDual_iff
 #align is_min.of_dual IsMin.ofDual
 
 end LE
@@ -400,10 +400,10 @@ theorem not_isMax_of_lt (h : a < b) : ¬IsMax a := fun ha => ha.not_lt h
 #align not_is_max_of_lt not_isMax_of_lt
 -/
 
-alias not_isMin_of_lt ← LT.lt.not_isMin
+alias LT.lt.not_isMin := not_isMin_of_lt
 #align has_lt.lt.not_is_min LT.lt.not_isMin
 
-alias not_isMax_of_lt ← LT.lt.not_isMax
+alias LT.lt.not_isMax := not_isMax_of_lt
 #align has_lt.lt.not_is_max LT.lt.not_isMax
 
 #print isMin_iff_forall_not_lt /-

6623e6af

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) 2014 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Yury Kudryashov, Yaël Dillies
-
-! This file was ported from Lean 3 source module order.max
-! leanprover-community/mathlib commit 6623e6af705e97002a9054c1c05a980180276fc1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.Synonym
 
+#align_import order.max from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"
+
 /-!
 # Minimal/maximal and bottom/top elements

6623e6af

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -113,21 +113,29 @@ instance OrderDual.noMaxOrder (α : Type _) [LT α] [NoMinOrder α] : NoMaxOrder
 #align order_dual.no_max_order OrderDual.noMaxOrder
 -/
 
+#print noMaxOrder_of_left /-
 instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_gt a; exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
 #align no_max_order_of_left noMaxOrder_of_left
+-/
 
+#print noMaxOrder_of_right /-
 instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_gt b; exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
 #align no_max_order_of_right noMaxOrder_of_right
+-/
 
+#print noMinOrder_of_left /-
 instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_lt a; exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
 #align no_min_order_of_left noMinOrder_of_left
+-/
 
+#print noMinOrder_of_right /-
 instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_lt b; exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
 #align no_min_order_of_right noMinOrder_of_right
+-/
 
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] : NoMaxOrder (∀ i, π i) :=
   ⟨fun a => by
@@ -505,61 +513,93 @@ section Prod
 
 variable [Preorder α] [Preorder β] {a a₁ a₂ : α} {b b₁ b₂ : β} {x y : α × β}
 
+#print IsBot.prod_mk /-
 theorem IsBot.prod_mk (ha : IsBot a) (hb : IsBot b) : IsBot (a, b) := fun c => ⟨ha _, hb _⟩
 #align is_bot.prod_mk IsBot.prod_mk
+-/
 
+#print IsTop.prod_mk /-
 theorem IsTop.prod_mk (ha : IsTop a) (hb : IsTop b) : IsTop (a, b) := fun c => ⟨ha _, hb _⟩
 #align is_top.prod_mk IsTop.prod_mk
+-/
 
+#print IsMin.prod_mk /-
 theorem IsMin.prod_mk (ha : IsMin a) (hb : IsMin b) : IsMin (a, b) := fun c hc => ⟨ha hc.1, hb hc.2⟩
 #align is_min.prod_mk IsMin.prod_mk
+-/
 
+#print IsMax.prod_mk /-
 theorem IsMax.prod_mk (ha : IsMax a) (hb : IsMax b) : IsMax (a, b) := fun c hc => ⟨ha hc.1, hb hc.2⟩
 #align is_max.prod_mk IsMax.prod_mk
+-/
 
+#print IsBot.fst /-
 theorem IsBot.fst (hx : IsBot x) : IsBot x.1 := fun c => (hx (c, x.2)).1
 #align is_bot.fst IsBot.fst
+-/
 
+#print IsBot.snd /-
 theorem IsBot.snd (hx : IsBot x) : IsBot x.2 := fun c => (hx (x.1, c)).2
 #align is_bot.snd IsBot.snd
+-/
 
+#print IsTop.fst /-
 theorem IsTop.fst (hx : IsTop x) : IsTop x.1 := fun c => (hx (c, x.2)).1
 #align is_top.fst IsTop.fst
+-/
 
+#print IsTop.snd /-
 theorem IsTop.snd (hx : IsTop x) : IsTop x.2 := fun c => (hx (x.1, c)).2
 #align is_top.snd IsTop.snd
+-/
 
+#print IsMin.fst /-
 theorem IsMin.fst (hx : IsMin x) : IsMin x.1 := fun c hc =>
   (hx <| show (c, x.2) ≤ x from (and_iff_left le_rfl).2 hc).1
 #align is_min.fst IsMin.fst
+-/
 
+#print IsMin.snd /-
 theorem IsMin.snd (hx : IsMin x) : IsMin x.2 := fun c hc =>
   (hx <| show (x.1, c) ≤ x from (and_iff_right le_rfl).2 hc).2
 #align is_min.snd IsMin.snd
+-/
 
+#print IsMax.fst /-
 theorem IsMax.fst (hx : IsMax x) : IsMax x.1 := fun c hc =>
   (hx <| show x ≤ (c, x.2) from (and_iff_left le_rfl).2 hc).1
 #align is_max.fst IsMax.fst
+-/
 
+#print IsMax.snd /-
 theorem IsMax.snd (hx : IsMax x) : IsMax x.2 := fun c hc =>
   (hx <| show x ≤ (x.1, c) from (and_iff_right le_rfl).2 hc).2
 #align is_max.snd IsMax.snd
+-/
 
+#print Prod.isBot_iff /-
 theorem Prod.isBot_iff : IsBot x ↔ IsBot x.1 ∧ IsBot x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_bot_iff Prod.isBot_iff
+-/
 
+#print Prod.isTop_iff /-
 theorem Prod.isTop_iff : IsTop x ↔ IsTop x.1 ∧ IsTop x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_top_iff Prod.isTop_iff
+-/
 
+#print Prod.isMin_iff /-
 theorem Prod.isMin_iff : IsMin x ↔ IsMin x.1 ∧ IsMin x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_min_iff Prod.isMin_iff
+-/
 
+#print Prod.isMax_iff /-
 theorem Prod.isMax_iff : IsMax x ↔ IsMax x.1 ∧ IsMax x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_max_iff Prod.isMax_iff
+-/
 
 end Prod

6623e6af

bump to nightly-2023-06-04-18

mathlib commit https://github.com/leanprover-community/mathlib/commit/5f25c089cb34db4db112556f23c50d12da81b297

3fb4268b

Diff

@@ -132,14 +132,14 @@ instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMin
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] : NoMaxOrder (∀ i, π i) :=
   ⟨fun a => by
     classical
-      obtain ⟨b, hb⟩ := exists_gt (a <| Classical.arbitrary _)
-      exact ⟨_, lt_update_self_iff.2 hb⟩⟩
+    obtain ⟨b, hb⟩ := exists_gt (a <| Classical.arbitrary _)
+    exact ⟨_, lt_update_self_iff.2 hb⟩⟩
 
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMinOrder (π i)] : NoMinOrder (∀ i, π i) :=
   ⟨fun a => by
     classical
-      obtain ⟨b, hb⟩ := exists_lt (a <| Classical.arbitrary _)
-      exact ⟨_, update_lt_self_iff.2 hb⟩⟩
+    obtain ⟨b, hb⟩ := exists_lt (a <| Classical.arbitrary _)
+    exact ⟨_, update_lt_self_iff.2 hb⟩⟩
 
 -- See note [lower instance priority]
 instance (priority := 100) NoMinOrder.to_noBotOrder (α : Type _) [Preorder α] [NoMinOrder α] :

6623e6af

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -153,14 +153,19 @@ instance (priority := 100) NoMaxOrder.to_noTopOrder (α : Type _) [Preorder α]
   ⟨fun a => (exists_gt a).imp fun _ => not_le_of_lt⟩
 #align no_max_order.to_no_top_order NoMaxOrder.to_noTopOrder
 
+#print NoBotOrder.to_noMinOrder /-
 theorem NoBotOrder.to_noMinOrder (α : Type _) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
   { exists_lt := by convert fun a : α => exists_not_ge a; simp_rw [not_le] }
 #align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrder
+-/
 
+#print NoTopOrder.to_noMaxOrder /-
 theorem NoTopOrder.to_noMaxOrder (α : Type _) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α :=
   { exists_gt := by convert fun a : α => exists_not_le a; simp_rw [not_le] }
 #align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrder
+-/
 
+#print noBotOrder_iff_noMinOrder /-
 theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
   ⟨fun h =>
     haveI := h
@@ -169,7 +174,9 @@ theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α
     haveI := h
     NoMinOrder.to_noBotOrder α⟩
 #align no_bot_order_iff_no_min_order noBotOrder_iff_noMinOrder
+-/
 
+#print noTopOrder_iff_noMaxOrder /-
 theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
   ⟨fun h =>
     haveI := h
@@ -178,6 +185,7 @@ theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α
     haveI := h
     NoMaxOrder.to_noTopOrder α⟩
 #align no_top_order_iff_no_max_order noTopOrder_iff_noMaxOrder
+-/
 
 #print NoMinOrder.not_acc /-
 theorem NoMinOrder.not_acc [LT α] [NoMinOrder α] (a : α) : ¬Acc (· < ·) a := fun h =>
@@ -345,31 +353,47 @@ section Preorder
 
 variable [Preorder α] {a b : α}
 
+#print IsBot.mono /-
 theorem IsBot.mono (ha : IsBot a) (h : b ≤ a) : IsBot b := fun c => h.trans <| ha _
 #align is_bot.mono IsBot.mono
+-/
 
+#print IsTop.mono /-
 theorem IsTop.mono (ha : IsTop a) (h : a ≤ b) : IsTop b := fun c => (ha _).trans h
 #align is_top.mono IsTop.mono
+-/
 
+#print IsMin.mono /-
 theorem IsMin.mono (ha : IsMin a) (h : b ≤ a) : IsMin b := fun c hc => h.trans <| ha <| hc.trans h
 #align is_min.mono IsMin.mono
+-/
 
+#print IsMax.mono /-
 theorem IsMax.mono (ha : IsMax a) (h : a ≤ b) : IsMax b := fun c hc => (ha <| h.trans hc).trans h
 #align is_max.mono IsMax.mono
+-/
 
+#print IsMin.not_lt /-
 theorem IsMin.not_lt (h : IsMin a) : ¬b < a := fun hb => hb.not_le <| h hb.le
 #align is_min.not_lt IsMin.not_lt
+-/
 
+#print IsMax.not_lt /-
 theorem IsMax.not_lt (h : IsMax a) : ¬a < b := fun hb => hb.not_le <| h hb.le
 #align is_max.not_lt IsMax.not_lt
+-/
 
+#print not_isMin_of_lt /-
 @[simp]
 theorem not_isMin_of_lt (h : b < a) : ¬IsMin a := fun ha => ha.not_lt h
 #align not_is_min_of_lt not_isMin_of_lt
+-/
 
+#print not_isMax_of_lt /-
 @[simp]
 theorem not_isMax_of_lt (h : a < b) : ¬IsMax a := fun ha => ha.not_lt h
 #align not_is_max_of_lt not_isMax_of_lt
+-/
 
 alias not_isMin_of_lt ← LT.lt.not_isMin
 #align has_lt.lt.not_is_min LT.lt.not_isMin
@@ -377,51 +401,71 @@ alias not_isMin_of_lt ← LT.lt.not_isMin
 alias not_isMax_of_lt ← LT.lt.not_isMax
 #align has_lt.lt.not_is_max LT.lt.not_isMax
 
+#print isMin_iff_forall_not_lt /-
 theorem isMin_iff_forall_not_lt : IsMin a ↔ ∀ b, ¬b < a :=
   ⟨fun h _ => h.not_lt, fun h b hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩
 #align is_min_iff_forall_not_lt isMin_iff_forall_not_lt
+-/
 
+#print isMax_iff_forall_not_lt /-
 theorem isMax_iff_forall_not_lt : IsMax a ↔ ∀ b, ¬a < b :=
   ⟨fun h _ => h.not_lt, fun h b hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩
 #align is_max_iff_forall_not_lt isMax_iff_forall_not_lt
+-/
 
+#print not_isMin_iff /-
 @[simp]
 theorem not_isMin_iff : ¬IsMin a ↔ ∃ b, b < a := by
   simp_rw [lt_iff_le_not_le, IsMin, not_forall, exists_prop]
 #align not_is_min_iff not_isMin_iff
+-/
 
+#print not_isMax_iff /-
 @[simp]
 theorem not_isMax_iff : ¬IsMax a ↔ ∃ b, a < b := by
   simp_rw [lt_iff_le_not_le, IsMax, not_forall, exists_prop]
 #align not_is_max_iff not_isMax_iff
+-/
 
+#print not_isMin /-
 @[simp]
 theorem not_isMin [NoMinOrder α] (a : α) : ¬IsMin a :=
   not_isMin_iff.2 <| exists_lt a
 #align not_is_min not_isMin
+-/
 
+#print not_isMax /-
 @[simp]
 theorem not_isMax [NoMaxOrder α] (a : α) : ¬IsMax a :=
   not_isMax_iff.2 <| exists_gt a
 #align not_is_max not_isMax
+-/
 
 namespace Subsingleton
 
 variable [Subsingleton α]
 
+#print Subsingleton.isBot /-
 protected theorem isBot (a : α) : IsBot a := fun _ => (Subsingleton.elim _ _).le
 #align subsingleton.is_bot Subsingleton.isBot
+-/
 
+#print Subsingleton.isTop /-
 protected theorem isTop (a : α) : IsTop a := fun _ => (Subsingleton.elim _ _).le
 #align subsingleton.is_top Subsingleton.isTop
+-/
 
+#print Subsingleton.isMin /-
 protected theorem isMin (a : α) : IsMin a :=
   (Subsingleton.isBot _).IsMin
 #align subsingleton.is_min Subsingleton.isMin
+-/
 
+#print Subsingleton.isMax /-
 protected theorem isMax (a : α) : IsMax a :=
   (Subsingleton.isTop _).IsMax
 #align subsingleton.is_max Subsingleton.isMax
+-/
 
 end Subsingleton
 
@@ -431,21 +475,29 @@ section PartialOrder
 
 variable [PartialOrder α] {a b : α}
 
+#print IsMin.eq_of_le /-
 protected theorem IsMin.eq_of_le (ha : IsMin a) (h : b ≤ a) : b = a :=
   h.antisymm <| ha h
 #align is_min.eq_of_le IsMin.eq_of_le
+-/
 
+#print IsMin.eq_of_ge /-
 protected theorem IsMin.eq_of_ge (ha : IsMin a) (h : b ≤ a) : a = b :=
   h.antisymm' <| ha h
 #align is_min.eq_of_ge IsMin.eq_of_ge
+-/
 
+#print IsMax.eq_of_le /-
 protected theorem IsMax.eq_of_le (ha : IsMax a) (h : a ≤ b) : a = b :=
   h.antisymm <| ha h
 #align is_max.eq_of_le IsMax.eq_of_le
+-/
 
+#print IsMax.eq_of_ge /-
 protected theorem IsMax.eq_of_ge (ha : IsMax a) (h : a ≤ b) : b = a :=
   h.antisymm' <| ha h
 #align is_max.eq_of_ge IsMax.eq_of_ge
+-/
 
 end PartialOrder

6623e6af

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -113,42 +113,18 @@ instance OrderDual.noMaxOrder (α : Type _) [LT α] [NoMinOrder α] : NoMaxOrder
 #align order_dual.no_max_order OrderDual.noMaxOrder
 -/
 
-/- warning: no_max_order_of_left -> 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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
-Case conversion may be inaccurate. Consider using '#align no_max_order_of_left noMaxOrder_of_leftₓ'. -/
 instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_gt a; exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
 #align no_max_order_of_left noMaxOrder_of_left
 
-/- warning: no_max_order_of_right -> 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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
-Case conversion may be inaccurate. Consider using '#align no_max_order_of_right noMaxOrder_of_rightₓ'. -/
 instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_gt b; exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
 #align no_max_order_of_right noMaxOrder_of_right
 
-/- warning: no_min_order_of_left -> 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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
-Case conversion may be inaccurate. Consider using '#align no_min_order_of_left noMinOrder_of_leftₓ'. -/
 instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_lt a; exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
 #align no_min_order_of_left noMinOrder_of_left
 
-/- warning: no_min_order_of_right -> 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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
-Case conversion may be inaccurate. Consider using '#align no_min_order_of_right noMinOrder_of_rightₓ'. -/
 instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α × β) :=
   ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_lt b; exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
 #align no_min_order_of_right noMinOrder_of_right
@@ -177,32 +153,14 @@ instance (priority := 100) NoMaxOrder.to_noTopOrder (α : Type _) [Preorder α]
   ⟨fun a => (exists_gt a).imp fun _ => not_le_of_lt⟩
 #align no_max_order.to_no_top_order NoMaxOrder.to_noTopOrder
 
-/- warning: no_bot_order.to_no_min_order -> NoBotOrder.to_noMinOrder is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoBotOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoBotOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrderₓ'. -/
 theorem NoBotOrder.to_noMinOrder (α : Type _) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
   { exists_lt := by convert fun a : α => exists_not_ge a; simp_rw [not_le] }
 #align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrder
 
-/- warning: no_top_order.to_no_max_order -> NoTopOrder.to_noMaxOrder is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoTopOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoTopOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
-Case conversion may be inaccurate. Consider using '#align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrderₓ'. -/
 theorem NoTopOrder.to_noMaxOrder (α : Type _) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α :=
   { exists_gt := by convert fun a : α => exists_not_le a; simp_rw [not_le] }
 #align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrder
 
-/- warning: no_bot_order_iff_no_min_order -> noBotOrder_iff_noMinOrder is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoBotOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoBotOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align no_bot_order_iff_no_min_order noBotOrder_iff_noMinOrderₓ'. -/
 theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
   ⟨fun h =>
     haveI := h
@@ -212,12 +170,6 @@ theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α
     NoMinOrder.to_noBotOrder α⟩
 #align no_bot_order_iff_no_min_order noBotOrder_iff_noMinOrder
 
-/- warning: no_top_order_iff_no_max_order -> noTopOrder_iff_noMaxOrder is a dubious translation:
-lean 3 declaration is
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoTopOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
-but is expected to have type
-  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoTopOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
-Case conversion may be inaccurate. Consider using '#align no_top_order_iff_no_max_order noTopOrder_iff_noMaxOrderₓ'. -/
 theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
   ⟨fun h =>
     haveI := h
@@ -393,157 +345,61 @@ section Preorder
 
 variable [Preorder α] {a b : α}
 
-/- warning: is_bot.mono -> IsBot.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a) -> (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a) -> (IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align is_bot.mono IsBot.monoₓ'. -/
 theorem IsBot.mono (ha : IsBot a) (h : b ≤ a) : IsBot b := fun c => h.trans <| ha _
 #align is_bot.mono IsBot.mono
 
-/- warning: is_top.mono -> IsTop.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align is_top.mono IsTop.monoₓ'. -/
 theorem IsTop.mono (ha : IsTop a) (h : a ≤ b) : IsTop b := fun c => (ha _).trans h
 #align is_top.mono IsTop.mono
 
-/- warning: is_min.mono -> IsMin.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align is_min.mono IsMin.monoₓ'. -/
 theorem IsMin.mono (ha : IsMin a) (h : b ≤ a) : IsMin b := fun c hc => h.trans <| ha <| hc.trans h
 #align is_min.mono IsMin.mono
 
-/- warning: is_max.mono -> IsMax.mono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
-Case conversion may be inaccurate. Consider using '#align is_max.mono IsMax.monoₓ'. -/
 theorem IsMax.mono (ha : IsMax a) (h : a ≤ b) : IsMax b := fun c hc => (ha <| h.trans hc).trans h
 #align is_max.mono IsMax.mono
 
-/- warning: is_min.not_lt -> IsMin.not_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align is_min.not_lt IsMin.not_ltₓ'. -/
 theorem IsMin.not_lt (h : IsMin a) : ¬b < a := fun hb => hb.not_le <| h hb.le
 #align is_min.not_lt IsMin.not_lt
 
-/- warning: is_max.not_lt -> IsMax.not_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align is_max.not_lt IsMax.not_ltₓ'. -/
 theorem IsMax.not_lt (h : IsMax a) : ¬a < b := fun hb => hb.not_le <| h hb.le
 #align is_max.not_lt IsMax.not_lt
 
-/- warning: not_is_min_of_lt -> not_isMin_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align not_is_min_of_lt not_isMin_of_ltₓ'. -/
 @[simp]
 theorem not_isMin_of_lt (h : b < a) : ¬IsMin a := fun ha => ha.not_lt h
 #align not_is_min_of_lt not_isMin_of_lt
 
-/- warning: not_is_max_of_lt -> not_isMax_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align not_is_max_of_lt not_isMax_of_ltₓ'. -/
 @[simp]
 theorem not_isMax_of_lt (h : a < b) : ¬IsMax a := fun ha => ha.not_lt h
 #align not_is_max_of_lt not_isMax_of_lt
 
-/- warning: has_lt.lt.not_is_min -> LT.lt.not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align has_lt.lt.not_is_min LT.lt.not_isMinₓ'. -/
 alias not_isMin_of_lt ← LT.lt.not_isMin
 #align has_lt.lt.not_is_min LT.lt.not_isMin
 
-/- warning: has_lt.lt.not_is_max -> LT.lt.not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align has_lt.lt.not_is_max LT.lt.not_isMaxₓ'. -/
 alias not_isMax_of_lt ← LT.lt.not_isMax
 #align has_lt.lt.not_is_max LT.lt.not_isMax
 
-/- warning: is_min_iff_forall_not_lt -> isMin_iff_forall_not_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align is_min_iff_forall_not_lt isMin_iff_forall_not_ltₓ'. -/
 theorem isMin_iff_forall_not_lt : IsMin a ↔ ∀ b, ¬b < a :=
   ⟨fun h _ => h.not_lt, fun h b hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩
 #align is_min_iff_forall_not_lt isMin_iff_forall_not_lt
 
-/- warning: is_max_iff_forall_not_lt -> isMax_iff_forall_not_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align is_max_iff_forall_not_lt isMax_iff_forall_not_ltₓ'. -/
 theorem isMax_iff_forall_not_lt : IsMax a ↔ ∀ b, ¬a < b :=
   ⟨fun h _ => h.not_lt, fun h b hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩
 #align is_max_iff_forall_not_lt isMax_iff_forall_not_lt
 
-/- warning: not_is_min_iff -> not_isMin_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align not_is_min_iff not_isMin_iffₓ'. -/
 @[simp]
 theorem not_isMin_iff : ¬IsMin a ↔ ∃ b, b < a := by
   simp_rw [lt_iff_le_not_le, IsMin, not_forall, exists_prop]
 #align not_is_min_iff not_isMin_iff
 
-/- warning: not_is_max_iff -> not_isMax_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align not_is_max_iff not_isMax_iffₓ'. -/
 @[simp]
 theorem not_isMax_iff : ¬IsMax a ↔ ∃ b, a < b := by
   simp_rw [lt_iff_le_not_le, IsMax, not_forall, exists_prop]
 #align not_is_max_iff not_isMax_iff
 
-/- warning: not_is_min -> not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align not_is_min not_isMinₓ'. -/
 @[simp]
 theorem not_isMin [NoMinOrder α] (a : α) : ¬IsMin a :=
   not_isMin_iff.2 <| exists_lt a
 #align not_is_min not_isMin
 
-/- warning: not_is_max -> not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align not_is_max not_isMaxₓ'. -/
 @[simp]
 theorem not_isMax [NoMaxOrder α] (a : α) : ¬IsMax a :=
   not_isMax_iff.2 <| exists_gt a
@@ -553,40 +409,16 @@ namespace Subsingleton
 
 variable [Subsingleton α]
 
-/- warning: subsingleton.is_bot -> Subsingleton.isBot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) a
-Case conversion may be inaccurate. Consider using '#align subsingleton.is_bot Subsingleton.isBotₓ'. -/
 protected theorem isBot (a : α) : IsBot a := fun _ => (Subsingleton.elim _ _).le
 #align subsingleton.is_bot Subsingleton.isBot
 
-/- warning: subsingleton.is_top -> Subsingleton.isTop is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) a
-Case conversion may be inaccurate. Consider using '#align subsingleton.is_top Subsingleton.isTopₓ'. -/
 protected theorem isTop (a : α) : IsTop a := fun _ => (Subsingleton.elim _ _).le
 #align subsingleton.is_top Subsingleton.isTop
 
-/- warning: subsingleton.is_min -> Subsingleton.isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a
-Case conversion may be inaccurate. Consider using '#align subsingleton.is_min Subsingleton.isMinₓ'. -/
 protected theorem isMin (a : α) : IsMin a :=
   (Subsingleton.isBot _).IsMin
 #align subsingleton.is_min Subsingleton.isMin
 
-/- warning: subsingleton.is_max -> Subsingleton.isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a
-Case conversion may be inaccurate. Consider using '#align subsingleton.is_max Subsingleton.isMaxₓ'. -/
 protected theorem isMax (a : α) : IsMax a :=
   (Subsingleton.isTop _).IsMax
 #align subsingleton.is_max Subsingleton.isMax
@@ -599,42 +431,18 @@ section PartialOrder
 
 variable [PartialOrder α] {a b : α}
 
-/- warning: is_min.eq_of_le -> IsMin.eq_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α b a)
-Case conversion may be inaccurate. Consider using '#align is_min.eq_of_le IsMin.eq_of_leₓ'. -/
 protected theorem IsMin.eq_of_le (ha : IsMin a) (h : b ≤ a) : b = a :=
   h.antisymm <| ha h
 #align is_min.eq_of_le IsMin.eq_of_le
 
-/- warning: is_min.eq_of_ge -> IsMin.eq_of_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align is_min.eq_of_ge IsMin.eq_of_geₓ'. -/
 protected theorem IsMin.eq_of_ge (ha : IsMin a) (h : b ≤ a) : a = b :=
   h.antisymm' <| ha h
 #align is_min.eq_of_ge IsMin.eq_of_ge
 
-/- warning: is_max.eq_of_le -> IsMax.eq_of_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align is_max.eq_of_le IsMax.eq_of_leₓ'. -/
 protected theorem IsMax.eq_of_le (ha : IsMax a) (h : a ≤ b) : a = b :=
   h.antisymm <| ha h
 #align is_max.eq_of_le IsMax.eq_of_le
 
-/- warning: is_max.eq_of_ge -> IsMax.eq_of_ge is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α b a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α b a)
-Case conversion may be inaccurate. Consider using '#align is_max.eq_of_ge IsMax.eq_of_geₓ'. -/
 protected theorem IsMax.eq_of_ge (ha : IsMax a) (h : a ≤ b) : b = a :=
   h.antisymm' <| ha h
 #align is_max.eq_of_ge IsMax.eq_of_ge
@@ -645,154 +453,58 @@ section Prod
 
 variable [Preorder α] [Preorder β] {a a₁ a₂ : α} {b b₁ b₂ : β} {x y : α × β}
 
-/- warning: is_bot.prod_mk -> IsBot.prod_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsBot.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsBot.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsBot.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
-Case conversion may be inaccurate. Consider using '#align is_bot.prod_mk IsBot.prod_mkₓ'. -/
 theorem IsBot.prod_mk (ha : IsBot a) (hb : IsBot b) : IsBot (a, b) := fun c => ⟨ha _, hb _⟩
 #align is_bot.prod_mk IsBot.prod_mk
 
-/- warning: is_top.prod_mk -> IsTop.prod_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsTop.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsTop.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsTop.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
-Case conversion may be inaccurate. Consider using '#align is_top.prod_mk IsTop.prod_mkₓ'. -/
 theorem IsTop.prod_mk (ha : IsTop a) (hb : IsTop b) : IsTop (a, b) := fun c => ⟨ha _, hb _⟩
 #align is_top.prod_mk IsTop.prod_mk
 
-/- warning: is_min.prod_mk -> IsMin.prod_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMin.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsMin.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
-Case conversion may be inaccurate. Consider using '#align is_min.prod_mk IsMin.prod_mkₓ'. -/
 theorem IsMin.prod_mk (ha : IsMin a) (hb : IsMin b) : IsMin (a, b) := fun c hc => ⟨ha hc.1, hb hc.2⟩
 #align is_min.prod_mk IsMin.prod_mk
 
-/- warning: is_max.prod_mk -> IsMax.prod_mk is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMax.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsMax.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
-Case conversion may be inaccurate. Consider using '#align is_max.prod_mk IsMax.prod_mkₓ'. -/
 theorem IsMax.prod_mk (ha : IsMax a) (hb : IsMax b) : IsMax (a, b) := fun c hc => ⟨ha hc.1, hb hc.2⟩
 #align is_max.prod_mk IsMax.prod_mk
 
-/- warning: is_bot.fst -> IsBot.fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsBot.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsBot.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_bot.fst IsBot.fstₓ'. -/
 theorem IsBot.fst (hx : IsBot x) : IsBot x.1 := fun c => (hx (c, x.2)).1
 #align is_bot.fst IsBot.fst
 
-/- warning: is_bot.snd -> IsBot.snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsBot.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsBot.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_bot.snd IsBot.sndₓ'. -/
 theorem IsBot.snd (hx : IsBot x) : IsBot x.2 := fun c => (hx (x.1, c)).2
 #align is_bot.snd IsBot.snd
 
-/- warning: is_top.fst -> IsTop.fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsTop.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsTop.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_top.fst IsTop.fstₓ'. -/
 theorem IsTop.fst (hx : IsTop x) : IsTop x.1 := fun c => (hx (c, x.2)).1
 #align is_top.fst IsTop.fst
 
-/- warning: is_top.snd -> IsTop.snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsTop.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsTop.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_top.snd IsTop.sndₓ'. -/
 theorem IsTop.snd (hx : IsTop x) : IsTop x.2 := fun c => (hx (x.1, c)).2
 #align is_top.snd IsTop.snd
 
-/- warning: is_min.fst -> IsMin.fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMin.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_min.fst IsMin.fstₓ'. -/
 theorem IsMin.fst (hx : IsMin x) : IsMin x.1 := fun c hc =>
   (hx <| show (c, x.2) ≤ x from (and_iff_left le_rfl).2 hc).1
 #align is_min.fst IsMin.fst
 
-/- warning: is_min.snd -> IsMin.snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMin.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMin.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_min.snd IsMin.sndₓ'. -/
 theorem IsMin.snd (hx : IsMin x) : IsMin x.2 := fun c hc =>
   (hx <| show (x.1, c) ≤ x from (and_iff_right le_rfl).2 hc).2
 #align is_min.snd IsMin.snd
 
-/- warning: is_max.fst -> IsMax.fst is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMax.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_max.fst IsMax.fstₓ'. -/
 theorem IsMax.fst (hx : IsMax x) : IsMax x.1 := fun c hc =>
   (hx <| show x ≤ (c, x.2) from (and_iff_left le_rfl).2 hc).1
 #align is_max.fst IsMax.fst
 
-/- warning: is_max.snd -> IsMax.snd is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMax.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMax.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
-Case conversion may be inaccurate. Consider using '#align is_max.snd IsMax.sndₓ'. -/
 theorem IsMax.snd (hx : IsMax x) : IsMax x.2 := fun c hc =>
   (hx <| show x ≤ (x.1, c) from (and_iff_right le_rfl).2 hc).2
 #align is_max.snd IsMax.snd
 
-/- warning: prod.is_bot_iff -> Prod.isBot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsBot.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsBot.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsBot.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
-Case conversion may be inaccurate. Consider using '#align prod.is_bot_iff Prod.isBot_iffₓ'. -/
 theorem Prod.isBot_iff : IsBot x ↔ IsBot x.1 ∧ IsBot x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_bot_iff Prod.isBot_iff
 
-/- warning: prod.is_top_iff -> Prod.isTop_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsTop.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsTop.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsTop.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
-Case conversion may be inaccurate. Consider using '#align prod.is_top_iff Prod.isTop_iffₓ'. -/
 theorem Prod.isTop_iff : IsTop x ↔ IsTop x.1 ∧ IsTop x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_top_iff Prod.isTop_iff
 
-/- warning: prod.is_min_iff -> Prod.isMin_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsMin.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsMin.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
-Case conversion may be inaccurate. Consider using '#align prod.is_min_iff Prod.isMin_iffₓ'. -/
 theorem Prod.isMin_iff : IsMin x ↔ IsMin x.1 ∧ IsMin x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_min_iff Prod.isMin_iff
 
-/- warning: prod.is_max_iff -> Prod.isMax_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
-but is expected to have type
-  forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsMax.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsMax.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
-Case conversion may be inaccurate. Consider using '#align prod.is_max_iff Prod.isMax_iffₓ'. -/
 theorem Prod.isMax_iff : IsMax x ↔ IsMax x.1 ∧ IsMax x.2 :=
   ⟨fun hx => ⟨hx.fst, hx.snd⟩, fun h => h.1.prod_mk h.2⟩
 #align prod.is_max_iff Prod.isMax_iff

6623e6af

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -120,9 +120,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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_max_order_of_left noMaxOrder_of_leftₓ'. -/
 instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α × β) :=
-  ⟨fun ⟨a, b⟩ => by
-    obtain ⟨c, h⟩ := exists_gt a
-    exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
+  ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_gt a; exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
 #align no_max_order_of_left noMaxOrder_of_left
 
 /- warning: no_max_order_of_right -> noMaxOrder_of_right is a dubious translation:
@@ -132,9 +130,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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_max_order_of_right noMaxOrder_of_rightₓ'. -/
 instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α × β) :=
-  ⟨fun ⟨a, b⟩ => by
-    obtain ⟨c, h⟩ := exists_gt b
-    exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
+  ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_gt b; exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
 #align no_max_order_of_right noMaxOrder_of_right
 
 /- warning: no_min_order_of_left -> noMinOrder_of_left is a dubious translation:
@@ -144,9 +140,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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_min_order_of_left noMinOrder_of_leftₓ'. -/
 instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α × β) :=
-  ⟨fun ⟨a, b⟩ => by
-    obtain ⟨c, h⟩ := exists_lt a
-    exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
+  ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_lt a; exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
 #align no_min_order_of_left noMinOrder_of_left
 
 /- warning: no_min_order_of_right -> noMinOrder_of_right is a dubious translation:
@@ -156,9 +150,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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_min_order_of_right noMinOrder_of_rightₓ'. -/
 instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α × β) :=
-  ⟨fun ⟨a, b⟩ => by
-    obtain ⟨c, h⟩ := exists_lt b
-    exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
+  ⟨fun ⟨a, b⟩ => by obtain ⟨c, h⟩ := exists_lt b; exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
 #align no_min_order_of_right noMinOrder_of_right
 
 instance [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] : NoMaxOrder (∀ i, π i) :=
@@ -192,10 +184,7 @@ but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoBotOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
 Case conversion may be inaccurate. Consider using '#align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrderₓ'. -/
 theorem NoBotOrder.to_noMinOrder (α : Type _) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
-  {
-    exists_lt := by
-      convert fun a : α => exists_not_ge a
-      simp_rw [not_le] }
+  { exists_lt := by convert fun a : α => exists_not_ge a; simp_rw [not_le] }
 #align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrder
 
 /- warning: no_top_order.to_no_max_order -> NoTopOrder.to_noMaxOrder is a dubious translation:
@@ -205,10 +194,7 @@ but is expected to have type
   forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoTopOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
 Case conversion may be inaccurate. Consider using '#align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrderₓ'. -/
 theorem NoTopOrder.to_noMaxOrder (α : Type _) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α :=
-  {
-    exists_gt := by
-      convert fun a : α => exists_not_le a
-      simp_rw [not_le] }
+  { exists_gt := by convert fun a : α => exists_not_le a; simp_rw [not_le] }
 #align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrder
 
 /- warning: no_bot_order_iff_no_min_order -> noBotOrder_iff_noMinOrder is a dubious translation:

6623e6af

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -115,7 +115,7 @@ instance OrderDual.noMaxOrder (α : Type _) [LT α] [NoMinOrder α] : NoMaxOrder
 
 /- warning: no_max_order_of_left -> 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.toLT.{u1} α _inst_1)], NoMaxOrder.{max u1 u2} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _inst_2))
+  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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_max_order_of_left noMaxOrder_of_leftₓ'. -/
@@ -127,7 +127,7 @@ instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxO
 
 /- warning: no_max_order_of_right -> 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.toLT.{u2} β _inst_2)], NoMaxOrder.{max u1 u2} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _inst_2))
+  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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_max_order_of_right noMaxOrder_of_rightₓ'. -/
@@ -139,7 +139,7 @@ instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMax
 
 /- warning: no_min_order_of_left -> 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.toLT.{u1} α _inst_1)], NoMinOrder.{max u1 u2} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _inst_2))
+  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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_min_order_of_left noMinOrder_of_leftₓ'. -/
@@ -151,7 +151,7 @@ instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinO
 
 /- warning: no_min_order_of_right -> 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.toLT.{u2} β _inst_2)], NoMinOrder.{max u1 u2} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _inst_2))
+  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} (Prod.{u1, u2} α β) (Preorder.toHasLt.{max u1 u2} (Prod.{u1, u2} α β) (Prod.preorder.{u1, u2} α β _inst_1 _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} (Prod.{u1, u2} α β) (Preorder.toLT.{max u1 u2} (Prod.{u1, u2} α β) (Prod.instPreorderProd.{u1, u2} α β _inst_1 _inst_2))
 Case conversion may be inaccurate. Consider using '#align no_min_order_of_right noMinOrder_of_rightₓ'. -/
@@ -185,25 +185,38 @@ instance (priority := 100) NoMaxOrder.to_noTopOrder (α : Type _) [Preorder α]
   ⟨fun a => (exists_gt a).imp fun _ => not_le_of_lt⟩
 #align no_max_order.to_no_top_order NoMaxOrder.to_noTopOrder
 
-#print NoBotOrder.to_noMinOrder /-
+/- warning: no_bot_order.to_no_min_order -> NoBotOrder.to_noMinOrder is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoBotOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoBotOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
+Case conversion may be inaccurate. Consider using '#align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrderₓ'. -/
 theorem NoBotOrder.to_noMinOrder (α : Type _) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
   {
     exists_lt := by
       convert fun a : α => exists_not_ge a
       simp_rw [not_le] }
 #align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrder
--/
 
-#print NoTopOrder.to_noMaxOrder /-
+/- warning: no_top_order.to_no_max_order -> NoTopOrder.to_noMaxOrder is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoTopOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α] [_inst_2 : NoTopOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))], NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))
+Case conversion may be inaccurate. Consider using '#align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrderₓ'. -/
 theorem NoTopOrder.to_noMaxOrder (α : Type _) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α :=
   {
     exists_gt := by
       convert fun a : α => exists_not_le a
       simp_rw [not_le] }
 #align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrder
--/
 
-#print noBotOrder_iff_noMinOrder /-
+/- warning: no_bot_order_iff_no_min_order -> noBotOrder_iff_noMinOrder is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoBotOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoBotOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
+Case conversion may be inaccurate. Consider using '#align no_bot_order_iff_no_min_order noBotOrder_iff_noMinOrderₓ'. -/
 theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
   ⟨fun h =>
     haveI := h
@@ -212,9 +225,13 @@ theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α
     haveI := h
     NoMinOrder.to_noBotOrder α⟩
 #align no_bot_order_iff_no_min_order noBotOrder_iff_noMinOrder
--/
 
-#print noTopOrder_iff_noMaxOrder /-
+/- warning: no_top_order_iff_no_max_order -> noTopOrder_iff_noMaxOrder is a dubious translation:
+lean 3 declaration is
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoTopOrder.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
+but is expected to have type
+  forall (α : Type.{u1}) [_inst_1 : LinearOrder.{u1} α], Iff (NoTopOrder.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1)))) (NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (LinearOrder.toPartialOrder.{u1} α _inst_1))))
+Case conversion may be inaccurate. Consider using '#align no_top_order_iff_no_max_order noTopOrder_iff_noMaxOrderₓ'. -/
 theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
   ⟨fun h =>
     haveI := h
@@ -223,7 +240,6 @@ theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α
     haveI := h
     NoMaxOrder.to_noTopOrder α⟩
 #align no_top_order_iff_no_max_order noTopOrder_iff_noMaxOrder
--/
 
 #print NoMinOrder.not_acc /-
 theorem NoMinOrder.not_acc [LT α] [NoMinOrder α] (a : α) : ¬Acc (· < ·) a := fun h =>
@@ -391,119 +407,203 @@ section Preorder
 
 variable [Preorder α] {a b : α}
 
-#print IsBot.mono /-
+/- warning: is_bot.mono -> IsBot.mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a) -> (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a) -> (IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align is_bot.mono IsBot.monoₓ'. -/
 theorem IsBot.mono (ha : IsBot a) (h : b ≤ a) : IsBot b := fun c => h.trans <| ha _
 #align is_bot.mono IsBot.mono
--/
 
-#print IsTop.mono /-
+/- warning: is_top.mono -> IsTop.mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align is_top.mono IsTop.monoₓ'. -/
 theorem IsTop.mono (ha : IsTop a) (h : a ≤ b) : IsTop b := fun c => (ha _).trans h
 #align is_top.mono IsTop.mono
--/
 
-#print IsMin.mono /-
+/- warning: is_min.mono -> IsMin.mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align is_min.mono IsMin.monoₓ'. -/
 theorem IsMin.mono (ha : IsMin a) (h : b ≤ a) : IsMin b := fun c hc => h.trans <| ha <| hc.trans h
 #align is_min.mono IsMin.mono
--/
 
-#print IsMax.mono /-
+/- warning: is_max.mono -> IsMax.mono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)
+Case conversion may be inaccurate. Consider using '#align is_max.mono IsMax.monoₓ'. -/
 theorem IsMax.mono (ha : IsMax a) (h : a ≤ b) : IsMax b := fun c hc => (ha <| h.trans hc).trans h
 #align is_max.mono IsMax.mono
--/
 
-#print IsMin.not_lt /-
+/- warning: is_min.not_lt -> IsMin.not_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align is_min.not_lt IsMin.not_ltₓ'. -/
 theorem IsMin.not_lt (h : IsMin a) : ¬b < a := fun hb => hb.not_le <| h hb.le
 #align is_min.not_lt IsMin.not_lt
--/
 
-#print IsMax.not_lt /-
+/- warning: is_max.not_lt -> IsMax.not_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align is_max.not_lt IsMax.not_ltₓ'. -/
 theorem IsMax.not_lt (h : IsMax a) : ¬a < b := fun hb => hb.not_le <| h hb.le
 #align is_max.not_lt IsMax.not_lt
--/
 
-#print not_isMin_of_lt /-
+/- warning: not_is_min_of_lt -> not_isMin_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align not_is_min_of_lt not_isMin_of_ltₓ'. -/
 @[simp]
 theorem not_isMin_of_lt (h : b < a) : ¬IsMin a := fun ha => ha.not_lt h
 #align not_is_min_of_lt not_isMin_of_lt
--/
 
-#print not_isMax_of_lt /-
+/- warning: not_is_max_of_lt -> not_isMax_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align not_is_max_of_lt not_isMax_of_ltₓ'. -/
 @[simp]
 theorem not_isMax_of_lt (h : a < b) : ¬IsMax a := fun ha => ha.not_lt h
 #align not_is_max_of_lt not_isMax_of_lt
--/
 
+/- warning: has_lt.lt.not_is_min -> LT.lt.not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a) -> (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align has_lt.lt.not_is_min LT.lt.not_isMinₓ'. -/
 alias not_isMin_of_lt ← LT.lt.not_isMin
 #align has_lt.lt.not_is_min LT.lt.not_isMin
 
+/- warning: has_lt.lt.not_is_max -> LT.lt.not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align has_lt.lt.not_is_max LT.lt.not_isMaxₓ'. -/
 alias not_isMax_of_lt ← LT.lt.not_isMax
 #align has_lt.lt.not_is_max LT.lt.not_isMax
 
-#print isMin_iff_forall_not_lt /-
+/- warning: is_min_iff_forall_not_lt -> isMin_iff_forall_not_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align is_min_iff_forall_not_lt isMin_iff_forall_not_ltₓ'. -/
 theorem isMin_iff_forall_not_lt : IsMin a ↔ ∀ b, ¬b < a :=
   ⟨fun h _ => h.not_lt, fun h b hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩
 #align is_min_iff_forall_not_lt isMin_iff_forall_not_lt
--/
 
-#print isMax_iff_forall_not_lt /-
+/- warning: is_max_iff_forall_not_lt -> isMax_iff_forall_not_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) (forall (b : α), Not (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align is_max_iff_forall_not_lt isMax_iff_forall_not_ltₓ'. -/
 theorem isMax_iff_forall_not_lt : IsMax a ↔ ∀ b, ¬a < b :=
   ⟨fun h _ => h.not_lt, fun h b hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩
 #align is_max_iff_forall_not_lt isMax_iff_forall_not_lt
--/
 
-#print not_isMin_iff /-
+/- warning: not_is_min_iff -> not_isMin_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align not_is_min_iff not_isMin_iffₓ'. -/
 @[simp]
 theorem not_isMin_iff : ¬IsMin a ↔ ∃ b, b < a := by
   simp_rw [lt_iff_le_not_le, IsMin, not_forall, exists_prop]
 #align not_is_min_iff not_isMin_iff
--/
 
-#print not_isMax_iff /-
+/- warning: not_is_max_iff -> not_isMax_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, Iff (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) (Exists.{succ u1} α (fun (b : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align not_is_max_iff not_isMax_iffₓ'. -/
 @[simp]
 theorem not_isMax_iff : ¬IsMax a ↔ ∃ b, a < b := by
   simp_rw [lt_iff_le_not_le, IsMax, not_forall, exists_prop]
 #align not_is_max_iff not_isMax_iff
--/
 
-#print not_isMin /-
+/- warning: not_is_min -> not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align not_is_min not_isMinₓ'. -/
 @[simp]
 theorem not_isMin [NoMinOrder α] (a : α) : ¬IsMin a :=
   not_isMin_iff.2 <| exists_lt a
 #align not_is_min not_isMin
--/
 
-#print not_isMax /-
+/- warning: not_is_max -> not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align not_is_max not_isMaxₓ'. -/
 @[simp]
 theorem not_isMax [NoMaxOrder α] (a : α) : ¬IsMax a :=
   not_isMax_iff.2 <| exists_gt a
 #align not_is_max not_isMax
--/
 
 namespace Subsingleton
 
 variable [Subsingleton α]
 
-#print Subsingleton.isBot /-
+/- warning: subsingleton.is_bot -> Subsingleton.isBot is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) a
+Case conversion may be inaccurate. Consider using '#align subsingleton.is_bot Subsingleton.isBotₓ'. -/
 protected theorem isBot (a : α) : IsBot a := fun _ => (Subsingleton.elim _ _).le
 #align subsingleton.is_bot Subsingleton.isBot
--/
 
-#print Subsingleton.isTop /-
+/- warning: subsingleton.is_top -> Subsingleton.isTop is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) a
+Case conversion may be inaccurate. Consider using '#align subsingleton.is_top Subsingleton.isTopₓ'. -/
 protected theorem isTop (a : α) : IsTop a := fun _ => (Subsingleton.elim _ _).le
 #align subsingleton.is_top Subsingleton.isTop
--/
 
-#print Subsingleton.isMin /-
+/- warning: subsingleton.is_min -> Subsingleton.isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a
+Case conversion may be inaccurate. Consider using '#align subsingleton.is_min Subsingleton.isMinₓ'. -/
 protected theorem isMin (a : α) : IsMin a :=
   (Subsingleton.isBot _).IsMin
 #align subsingleton.is_min Subsingleton.isMin
--/
 
-#print Subsingleton.isMax /-
+/- warning: subsingleton.is_max -> Subsingleton.isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Subsingleton.{succ u1} α] (a : α), IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a
+Case conversion may be inaccurate. Consider using '#align subsingleton.is_max Subsingleton.isMaxₓ'. -/
 protected theorem isMax (a : α) : IsMax a :=
   (Subsingleton.isTop _).IsMax
 #align subsingleton.is_max Subsingleton.isMax
--/
 
 end Subsingleton
 
@@ -513,29 +613,45 @@ section PartialOrder
 
 variable [PartialOrder α] {a b : α}
 
-#print IsMin.eq_of_le /-
+/- warning: is_min.eq_of_le -> IsMin.eq_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α b a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α b a)
+Case conversion may be inaccurate. Consider using '#align is_min.eq_of_le IsMin.eq_of_leₓ'. -/
 protected theorem IsMin.eq_of_le (ha : IsMin a) (h : b ≤ a) : b = a :=
   h.antisymm <| ha h
 #align is_min.eq_of_le IsMin.eq_of_le
--/
 
-#print IsMin.eq_of_ge /-
+/- warning: is_min.eq_of_ge -> IsMin.eq_of_ge is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a) -> (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align is_min.eq_of_ge IsMin.eq_of_geₓ'. -/
 protected theorem IsMin.eq_of_ge (ha : IsMin a) (h : b ≤ a) : a = b :=
   h.antisymm' <| ha h
 #align is_min.eq_of_ge IsMin.eq_of_ge
--/
 
-#print IsMax.eq_of_le /-
+/- warning: is_max.eq_of_le -> IsMax.eq_of_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align is_max.eq_of_le IsMax.eq_of_leₓ'. -/
 protected theorem IsMax.eq_of_le (ha : IsMax a) (h : a ≤ b) : a = b :=
   h.antisymm <| ha h
 #align is_max.eq_of_le IsMax.eq_of_le
--/
 
-#print IsMax.eq_of_ge /-
+/- warning: is_max.eq_of_ge -> IsMax.eq_of_ge is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α b a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] {a : α} {b : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α b a)
+Case conversion may be inaccurate. Consider using '#align is_max.eq_of_ge IsMax.eq_of_geₓ'. -/
 protected theorem IsMax.eq_of_ge (ha : IsMax a) (h : a ≤ b) : b = a :=
   h.antisymm' <| ha h
 #align is_max.eq_of_ge IsMax.eq_of_ge
--/
 
 end PartialOrder
 
@@ -545,7 +661,7 @@ variable [Preorder α] [Preorder β] {a a₁ a₂ : α} {b b₁ b₂ : β} {x y
 
 /- warning: is_bot.prod_mk -> IsBot.prod_mk is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (IsBot.{u2} β (Preorder.toLE.{u2} β _inst_2) b) -> (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsBot.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsBot.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsBot.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
 Case conversion may be inaccurate. Consider using '#align is_bot.prod_mk IsBot.prod_mkₓ'. -/
@@ -554,7 +670,7 @@ theorem IsBot.prod_mk (ha : IsBot a) (hb : IsBot b) : IsBot (a, b) := fun c => 
 
 /- warning: is_top.prod_mk -> IsTop.prod_mk is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (IsTop.{u2} β (Preorder.toLE.{u2} β _inst_2) b) -> (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsTop.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsTop.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsTop.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
 Case conversion may be inaccurate. Consider using '#align is_top.prod_mk IsTop.prod_mkₓ'. -/
@@ -563,7 +679,7 @@ theorem IsTop.prod_mk (ha : IsTop a) (hb : IsTop b) : IsTop (a, b) := fun c => 
 
 /- warning: is_min.prod_mk -> IsMin.prod_mk is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (IsMin.{u2} β (Preorder.toLE.{u2} β _inst_2) b) -> (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMin.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsMin.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
 Case conversion may be inaccurate. Consider using '#align is_min.prod_mk IsMin.prod_mkₓ'. -/
@@ -572,7 +688,7 @@ theorem IsMin.prod_mk (ha : IsMin a) (hb : IsMin b) : IsMin (a, b) := fun c hc =
 
 /- warning: is_max.prod_mk -> IsMax.prod_mk is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (IsMax.{u2} β (Preorder.toLE.{u2} β _inst_2) b) -> (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {a : α} {b : β}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) b) -> (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) (Prod.mk.{u1, u2} α β a b))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {a : α} {b : β}, (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) a) -> (IsMax.{u1} β (Preorder.toLE.{u1} β _inst_2) b) -> (IsMax.{max u1 u2} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) (Prod.mk.{u2, u1} α β a b))
 Case conversion may be inaccurate. Consider using '#align is_max.prod_mk IsMax.prod_mkₓ'. -/
@@ -581,7 +697,7 @@ theorem IsMax.prod_mk (ha : IsMax a) (hb : IsMax b) : IsMax (a, b) := fun c hc =
 
 /- warning: is_bot.fst -> IsBot.fst is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsBot.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsBot.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_bot.fst IsBot.fstₓ'. -/
@@ -590,7 +706,7 @@ theorem IsBot.fst (hx : IsBot x) : IsBot x.1 := fun c => (hx (c, x.2)).1
 
 /- warning: is_bot.snd -> IsBot.snd is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsBot.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsBot.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsBot.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_bot.snd IsBot.sndₓ'. -/
@@ -599,7 +715,7 @@ theorem IsBot.snd (hx : IsBot x) : IsBot x.2 := fun c => (hx (x.1, c)).2
 
 /- warning: is_top.fst -> IsTop.fst is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsTop.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsTop.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_top.fst IsTop.fstₓ'. -/
@@ -608,7 +724,7 @@ theorem IsTop.fst (hx : IsTop x) : IsTop x.1 := fun c => (hx (c, x.2)).1
 
 /- warning: is_top.snd -> IsTop.snd is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsTop.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsTop.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsTop.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_top.snd IsTop.sndₓ'. -/
@@ -617,7 +733,7 @@ theorem IsTop.snd (hx : IsTop x) : IsTop x.2 := fun c => (hx (x.1, c)).2
 
 /- warning: is_min.fst -> IsMin.fst is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMin.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_min.fst IsMin.fstₓ'. -/
@@ -627,7 +743,7 @@ theorem IsMin.fst (hx : IsMin x) : IsMin x.1 := fun c hc =>
 
 /- warning: is_min.snd -> IsMin.snd is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsMin.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMin.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMin.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_min.snd IsMin.sndₓ'. -/
@@ -637,7 +753,7 @@ theorem IsMin.snd (hx : IsMin x) : IsMin x.2 := fun c hc =>
 
 /- warning: is_max.fst -> IsMax.fst is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMax.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_max.fst IsMax.fstₓ'. -/
@@ -647,7 +763,7 @@ theorem IsMax.fst (hx : IsMax x) : IsMax x.1 := fun c hc =>
 
 /- warning: is_max.snd -> IsMax.snd is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) -> (IsMax.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) -> (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, (IsMax.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) -> (IsMax.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x))
 Case conversion may be inaccurate. Consider using '#align is_max.snd IsMax.sndₓ'. -/
@@ -657,7 +773,7 @@ theorem IsMax.snd (hx : IsMax x) : IsMax x.2 := fun c hc =>
 
 /- warning: prod.is_bot_iff -> Prod.isBot_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) (And (IsBot.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsBot.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsBot.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsBot.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsBot.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsBot.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsBot.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
 Case conversion may be inaccurate. Consider using '#align prod.is_bot_iff Prod.isBot_iffₓ'. -/
@@ -667,7 +783,7 @@ theorem Prod.isBot_iff : IsBot x ↔ IsBot x.1 ∧ IsBot x.2 :=
 
 /- warning: prod.is_top_iff -> Prod.isTop_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) (And (IsTop.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsTop.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsTop.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsTop.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsTop.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsTop.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsTop.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
 Case conversion may be inaccurate. Consider using '#align prod.is_top_iff Prod.isTop_iffₓ'. -/
@@ -677,7 +793,7 @@ theorem Prod.isTop_iff : IsTop x ↔ IsTop x.1 ∧ IsTop x.2 :=
 
 /- warning: prod.is_min_iff -> Prod.isMin_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) (And (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsMin.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsMin.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsMin.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsMin.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsMin.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsMin.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
 Case conversion may be inaccurate. Consider using '#align prod.is_min_iff Prod.isMin_iffₓ'. -/
@@ -687,7 +803,7 @@ theorem Prod.isMin_iff : IsMin x ↔ IsMin x.1 ∧ IsMin x.2 :=
 
 /- warning: prod.is_max_iff -> Prod.isMax_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toLE.{u1} α _inst_1) (Preorder.toLE.{u2} β _inst_2)) x) (And (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsMax.{u2} β (Preorder.toLE.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
+  forall {α : Type.{u1}} {β : Type.{u2}} [_inst_1 : Preorder.{u1} α] [_inst_2 : Preorder.{u2} β] {x : Prod.{u1, u2} α β}, Iff (IsMax.{max u1 u2} (Prod.{u1, u2} α β) (Prod.hasLe.{u1, u2} α β (Preorder.toHasLe.{u1} α _inst_1) (Preorder.toHasLe.{u2} β _inst_2)) x) (And (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Prod.fst.{u1, u2} α β x)) (IsMax.{u2} β (Preorder.toHasLe.{u2} β _inst_2) (Prod.snd.{u1, u2} α β x)))
 but is expected to have type
   forall {α : Type.{u2}} {β : Type.{u1}} [_inst_1 : Preorder.{u2} α] [_inst_2 : Preorder.{u1} β] {x : Prod.{u2, u1} α β}, Iff (IsMax.{max u2 u1} (Prod.{u2, u1} α β) (Prod.instLEProd.{u2, u1} α β (Preorder.toLE.{u2} α _inst_1) (Preorder.toLE.{u1} β _inst_2)) x) (And (IsMax.{u2} α (Preorder.toLE.{u2} α _inst_1) (Prod.fst.{u2, u1} α β x)) (IsMax.{u1} β (Preorder.toLE.{u1} β _inst_2) (Prod.snd.{u2, u1} α β x)))
 Case conversion may be inaccurate. Consider using '#align prod.is_max_iff Prod.isMax_iffₓ'. -/

6623e6af

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

6623e6af

refactor: replace some [@foo](https://github.com/foo) _ _ _ _ _ ... by named arguments (#8702)

Using Lean4's named arguments, we manage to remove a few hard-to-read explicit function calls [@foo](https://github.com/foo) _ _ _ _ _ ... which used to be necessary in Lean3.

Occasionally, this results in slightly longer code. The benefit of named arguments is readability, as well as to reduce the brittleness of the code when the argument order is changed.

Co-authored-by: Michael Rothgang <rothgami@math.hu-berlin.de>

df634f2a

Diff

@@ -79,19 +79,19 @@ instance IsEmpty.toNoMaxOrder [LT α] [IsEmpty α] : NoMaxOrder α := ⟨isEmpty
 instance IsEmpty.toNoMinOrder [LT α] [IsEmpty α] : NoMinOrder α := ⟨isEmptyElim⟩
 
 instance OrderDual.noBotOrder [LE α] [NoTopOrder α] : NoBotOrder αᵒᵈ :=
-  ⟨fun a => @exists_not_le α _ _ a⟩
+  ⟨fun a => exists_not_le (α := α) a⟩
 #align order_dual.no_bot_order OrderDual.noBotOrder
 
 instance OrderDual.noTopOrder [LE α] [NoBotOrder α] : NoTopOrder αᵒᵈ :=
-  ⟨fun a => @exists_not_ge α _ _ a⟩
+  ⟨fun a => exists_not_ge (α := α) a⟩
 #align order_dual.no_top_order OrderDual.noTopOrder
 
 instance OrderDual.noMinOrder [LT α] [NoMaxOrder α] : NoMinOrder αᵒᵈ :=
-  ⟨fun a => @exists_gt α _ _ a⟩
+  ⟨fun a => exists_gt (α := α) a⟩
 #align order_dual.no_min_order OrderDual.noMinOrder
 
 instance OrderDual.noMaxOrder [LT α] [NoMinOrder α] : NoMaxOrder αᵒᵈ :=
-  ⟨fun a => @exists_lt α _ _ a⟩
+  ⟨fun a => exists_lt (α := α) a⟩
 #align order_dual.no_max_order OrderDual.noMaxOrder
 
 -- See note [lower instance priority]

6623e6af

feat: The range in a succ order is unbounded (#6883)

Strictly monotone/antitone functions from an order without top/bottom to a succ/pred order have unbounded range.

b6962296

Diff

@@ -75,6 +75,9 @@ instance nonempty_lt [LT α] [NoMinOrder α] (a : α) : Nonempty { x // x < a }
 instance nonempty_gt [LT α] [NoMaxOrder α] (a : α) : Nonempty { x // a < x } :=
   nonempty_subtype.2 (exists_gt a)
 
+instance IsEmpty.toNoMaxOrder [LT α] [IsEmpty α] : NoMaxOrder α := ⟨isEmptyElim⟩
+instance IsEmpty.toNoMinOrder [LT α] [IsEmpty α] : NoMinOrder α := ⟨isEmptyElim⟩
+
 instance OrderDual.noBotOrder [LE α] [NoTopOrder α] : NoBotOrder αᵒᵈ :=
   ⟨fun a => @exists_not_le α _ _ a⟩
 #align order_dual.no_bot_order OrderDual.noBotOrder

6623e6af

feat: patch for new alias command (#6172)

19e0ba92

Diff

@@ -265,28 +265,28 @@ theorem isMax_ofDual_iff {a : αᵒᵈ} : IsMax (ofDual a) ↔ IsMin a :=
   Iff.rfl
 #align is_max_of_dual_iff isMax_ofDual_iff
 
-alias isBot_toDual_iff ↔ _ IsTop.toDual
+alias ⟨_, IsTop.toDual⟩ := isBot_toDual_iff
 #align is_top.to_dual IsTop.toDual
 
-alias isTop_toDual_iff ↔ _ IsBot.toDual
+alias ⟨_, IsBot.toDual⟩ := isTop_toDual_iff
 #align is_bot.to_dual IsBot.toDual
 
-alias isMin_toDual_iff ↔ _ IsMax.toDual
+alias ⟨_, IsMax.toDual⟩ := isMin_toDual_iff
 #align is_max.to_dual IsMax.toDual
 
-alias isMax_toDual_iff ↔ _ IsMin.toDual
+alias ⟨_, IsMin.toDual⟩ := isMax_toDual_iff
 #align is_min.to_dual IsMin.toDual
 
-alias isBot_ofDual_iff ↔ _ IsTop.ofDual
+alias ⟨_, IsTop.ofDual⟩ := isBot_ofDual_iff
 #align is_top.of_dual IsTop.ofDual
 
-alias isTop_ofDual_iff ↔ _ IsBot.ofDual
+alias ⟨_, IsBot.ofDual⟩ := isTop_ofDual_iff
 #align is_bot.of_dual IsBot.ofDual
 
-alias isMin_ofDual_iff ↔ _ IsMax.ofDual
+alias ⟨_, IsMax.ofDual⟩ := isMin_ofDual_iff
 #align is_max.of_dual IsMax.ofDual
 
-alias isMax_ofDual_iff ↔ _ IsMin.ofDual
+alias ⟨_, IsMin.ofDual⟩ := isMax_ofDual_iff
 #align is_min.of_dual IsMin.ofDual
 
 end LE
@@ -321,9 +321,9 @@ theorem not_isMin_of_lt (h : b < a) : ¬IsMin a := fun ha => ha.not_lt h
 theorem not_isMax_of_lt (h : a < b) : ¬IsMax a := fun ha => ha.not_lt h
 #align not_is_max_of_lt not_isMax_of_lt
 
-alias not_isMin_of_lt ← LT.lt.not_isMin
+alias LT.lt.not_isMin := not_isMin_of_lt
 
-alias not_isMax_of_lt ← LT.lt.not_isMax
+alias LT.lt.not_isMax := not_isMax_of_lt
 
 theorem isMin_iff_forall_not_lt : IsMin a ↔ ∀ b, ¬b < a :=
   ⟨fun h _ => h.not_lt, fun h _ hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩

6623e6af

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

@@ -35,28 +35,28 @@ open OrderDual
 
 universe u v
 
-variable {α β : Type _}
+variable {α β : Type*}
 
 /-- Order without bottom elements. -/
-class NoBotOrder (α : Type _) [LE α] : Prop where
+class NoBotOrder (α : Type*) [LE α] : Prop where
   /-- For each term `a`, there is some `b` which is either incomparable or strictly smaller. -/
   exists_not_ge (a : α) : ∃ b, ¬a ≤ b
 #align no_bot_order NoBotOrder
 
 /-- Order without top elements. -/
-class NoTopOrder (α : Type _) [LE α] : Prop where
+class NoTopOrder (α : Type*) [LE α] : Prop where
   /-- For each term `a`, there is some `b` which is either incomparable or strictly larger. -/
   exists_not_le (a : α) : ∃ b, ¬b ≤ a
 #align no_top_order NoTopOrder
 
 /-- Order without minimal elements. Sometimes called coinitial or dense. -/
-class NoMinOrder (α : Type _) [LT α] : Prop where
+class NoMinOrder (α : Type*) [LT α] : Prop where
   /-- For each term `a`, there is some strictly smaller `b`. -/
   exists_lt (a : α) : ∃ b, b < a
 #align no_min_order NoMinOrder
 
 /-- Order without maximal elements. Sometimes called cofinal. -/
-class NoMaxOrder (α : Type _) [LT α] : Prop where
+class NoMaxOrder (α : Type*) [LT α] : Prop where
   /-- For each term `a`, there is some strictly greater `b`. -/
   exists_gt (a : α) : ∃ b, a < b
 #align no_max_order NoMaxOrder
@@ -123,14 +123,14 @@ instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMin
     exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
 #align no_min_order_of_right noMinOrder_of_right
 
-instance {ι : Type u} {π : ι → Type _} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] :
+instance {ι : Type u} {π : ι → Type*} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] :
     NoMaxOrder (∀ i, π i) :=
   ⟨fun a => by
     classical
     obtain ⟨b, hb⟩ := exists_gt (a <| Classical.arbitrary _)
     exact ⟨_, lt_update_self_iff.2 hb⟩⟩
 
-instance {ι : Type u} {π : ι → Type _} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMinOrder (π i)] :
+instance {ι : Type u} {π : ι → Type*} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMinOrder (π i)] :
     NoMinOrder (∀ i, π i) :=
   ⟨fun a => by
      classical
@@ -138,16 +138,16 @@ instance {ι : Type u} {π : ι → Type _} [Nonempty ι] [∀ i, Preorder (π i
       exact ⟨_, update_lt_self_iff.2 hb⟩⟩
 
 -- Porting note: mathlib3 proof uses `convert`
-theorem NoBotOrder.to_noMinOrder (α : Type _) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
+theorem NoBotOrder.to_noMinOrder (α : Type*) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
   { exists_lt := fun a => by simpa [not_le] using exists_not_ge a }
 #align no_bot_order.to_no_min_order NoBotOrder.to_noMinOrder
 
 -- Porting note: mathlib3 proof uses `convert`
-theorem NoTopOrder.to_noMaxOrder (α : Type _) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α :=
+theorem NoTopOrder.to_noMaxOrder (α : Type*) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α :=
   { exists_gt := fun a => by simpa [not_le] using exists_not_le a }
 #align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrder
 
-theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
+theorem noBotOrder_iff_noMinOrder (α : Type*) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
   ⟨fun h =>
     haveI := h
     NoBotOrder.to_noMinOrder α,
@@ -156,7 +156,7 @@ theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α
     inferInstance⟩
 #align no_bot_order_iff_no_min_order noBotOrder_iff_noMinOrder
 
-theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
+theorem noTopOrder_iff_noMaxOrder (α : Type*) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
   ⟨fun h =>
     haveI := h
     NoTopOrder.to_noMaxOrder α,

6623e6af

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) 2014 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Yury Kudryashov, Yaël Dillies
-
-! This file was ported from Lean 3 source module order.max
-! leanprover-community/mathlib commit 6623e6af705e97002a9054c1c05a980180276fc1
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.Synonym
 
+#align_import order.max from "leanprover-community/mathlib"@"6623e6af705e97002a9054c1c05a980180276fc1"
+
 /-!
 # Minimal/maximal and bottom/top elements

6623e6af

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

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

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

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

a4eaf1c4

Diff

@@ -9,7 +9,6 @@ Authors: Jeremy Avigad, Yury Kudryashov, Yaël Dillies
 ! if you have ported upstream changes.
 -/
 import Mathlib.Order.Synonym
-import Mathlib.Tactic.Classical
 
 /-!
 # Minimal/maximal and bottom/top elements

6623e6af

chore: resync ported files (#2135)

This PR resyncs the first 28 entries of https://leanprover-community.github.io/mathlib-port-status/out-of-sync.html after sorting by diff size.

resync Mathlib/Data/Bool/Count
resync Mathlib/Order/Max
resync Mathlib/Algebra/EuclideanDomain/Instances
resync Mathlib/Data/List/Duplicate
resync Mathlib/Data/Multiset/Nodup
resync Mathlib/Data/Set/Pointwise/ListOfFn
resync Mathlib/Dynamics/FixedPoints/Basic
resync Mathlib/Order/OmegaCompletePartialOrder
resync Mathlib/Order/PropInstances
resync Mathlib/Topology/LocallyFinite
resync Mathlib/Data/Bool/Set
resync Mathlib/Data/Fintype/Card
resync Mathlib/Data/Multiset/Bind
resync Mathlib/Data/Rat/Floor
resync Mathlib/Algebra/Order/Floor
resync Mathlib/Data/Int/Basic
resync Mathlib/Data/Int/Dvd/Basic
resync Mathlib/Data/List/Sort
resync Mathlib/Data/Nat/GCD/Basic
resync Mathlib/Data/Set/Enumerate
resync Mathlib/Data/Set/Intervals/OrdConnectedComponent
resync Mathlib/GroupTheory/Subsemigroup/Basic
resync Mathlib/Topology/Connected
resync Mathlib/Topology/NhdsSet
resync Mathlib/Algebra/BigOperators/Multiset/Lemmas
resync Mathlib/Algebra/CharZero/Infinite
resync Mathlib/Data/Multiset/Range
resync Mathlib/Data/Set/Pointwise/Finite

a7eb5ab3

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Yury Kudryashov, Yaël Dillies
 
 ! This file was ported from Lean 3 source module order.max
-! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
+! leanprover-community/mathlib commit 6623e6af705e97002a9054c1c05a980180276fc1
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/

c4658a64

chore: add missing #align statements (#1902)

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

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

b72bb858

Diff

@@ -158,6 +158,7 @@ theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α
     fun h =>
     haveI := h
     inferInstance⟩
+#align no_bot_order_iff_no_min_order noBotOrder_iff_noMinOrder
 
 theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
   ⟨fun h =>
@@ -166,12 +167,15 @@ theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α
     fun h =>
     haveI := h
     inferInstance⟩
+#align no_top_order_iff_no_max_order noTopOrder_iff_noMaxOrder
 
 theorem NoMinOrder.not_acc [LT α] [NoMinOrder α] (a : α) : ¬Acc (· < ·) a := fun h =>
   Acc.recOn h fun x _ => (exists_lt x).recOn
+#align no_min_order.not_acc NoMinOrder.not_acc
 
 theorem NoMaxOrder.not_acc [LT α] [NoMaxOrder α] (a : α) : ¬Acc (· > ·) a := fun h =>
   Acc.recOn h fun x _ => (exists_gt x).recOn
+#align no_max_order.not_acc NoMaxOrder.not_acc
 
 section LE
 
@@ -183,6 +187,7 @@ several bottom elements. When `α` is linear, this is useful to make a case disj
 `NoMinOrder α` within a proof. -/
 def IsBot (a : α) : Prop :=
   ∀ b, a ≤ b
+#align is_bot IsBot
 
 /-- `a : α` is a top element of `α` if it is greater than or equal to any other element of `α`.
 This predicate is roughly an unbundled version of `OrderBot`, except that a preorder may have
@@ -190,18 +195,21 @@ several top elements. When `α` is linear, this is useful to make a case disjunc
 `NoMaxOrder α` within a proof. -/
 def IsTop (a : α) : Prop :=
   ∀ b, b ≤ a
+#align is_top IsTop
 
 /-- `a` is a minimal element of `α` if no element is strictly less than it. We spell it without `<`
 to avoid having to convert between `≤` and `<`. Instead, `isMin_iff_forall_not_lt` does the
 conversion. -/
 def IsMin (a : α) : Prop :=
   ∀ ⦃b⦄, b ≤ a → a ≤ b
+#align is_min IsMin
 
 /-- `a` is a maximal element of `α` if no element is strictly greater than it. We spell it without
 `<` to avoid having to convert between `≤` and `<`. Instead, `isMax_iff_forall_not_lt` does the
 conversion. -/
 def IsMax (a : α) : Prop :=
   ∀ ⦃b⦄, a ≤ b → b ≤ a
+#align is_max IsMax
 
 @[simp]
 theorem not_isBot [NoBotOrder α] (a : α) : ¬IsBot a := fun h =>
@@ -262,20 +270,28 @@ theorem isMax_ofDual_iff {a : αᵒᵈ} : IsMax (ofDual a) ↔ IsMin a :=
 #align is_max_of_dual_iff isMax_ofDual_iff
 
 alias isBot_toDual_iff ↔ _ IsTop.toDual
+#align is_top.to_dual IsTop.toDual
 
 alias isTop_toDual_iff ↔ _ IsBot.toDual
+#align is_bot.to_dual IsBot.toDual
 
 alias isMin_toDual_iff ↔ _ IsMax.toDual
+#align is_max.to_dual IsMax.toDual
 
 alias isMax_toDual_iff ↔ _ IsMin.toDual
+#align is_min.to_dual IsMin.toDual
 
 alias isBot_ofDual_iff ↔ _ IsTop.ofDual
+#align is_top.of_dual IsTop.ofDual
 
 alias isTop_ofDual_iff ↔ _ IsBot.ofDual
+#align is_bot.of_dual IsBot.ofDual
 
 alias isMin_ofDual_iff ↔ _ IsMax.ofDual
+#align is_max.of_dual IsMax.ofDual
 
 alias isMax_ofDual_iff ↔ _ IsMin.ofDual
+#align is_min.of_dual IsMin.ofDual
 
 end LE

c4658a64

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

I've avoided anything under Tactic or test.

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

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

31a56f75

Diff

@@ -151,7 +151,7 @@ theorem NoTopOrder.to_noMaxOrder (α : Type _) [LinearOrder α] [NoTopOrder α]
   { exists_gt := fun a => by simpa [not_le] using exists_not_le a }
 #align no_top_order.to_no_max_order NoTopOrder.to_noMaxOrder
 
-theorem no_bot_order_iff_no_min_order (α : Type _) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
+theorem noBotOrder_iff_noMinOrder (α : Type _) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α :=
   ⟨fun h =>
     haveI := h
     NoBotOrder.to_noMinOrder α,
@@ -159,7 +159,7 @@ theorem no_bot_order_iff_no_min_order (α : Type _) [LinearOrder α] : NoBotOrde
     haveI := h
     inferInstance⟩
 
-theorem no_top_order_iff_no_max_order (α : Type _) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
+theorem noTopOrder_iff_noMaxOrder (α : Type _) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α :=
   ⟨fun h =>
     haveI := h
     NoTopOrder.to_noMaxOrder α,
@@ -309,9 +309,9 @@ theorem not_isMin_of_lt (h : b < a) : ¬IsMin a := fun ha => ha.not_lt h
 theorem not_isMax_of_lt (h : a < b) : ¬IsMax a := fun ha => ha.not_lt h
 #align not_is_max_of_lt not_isMax_of_lt
 
-alias not_isMin_of_lt ← LT.lt.not_is_min
+alias not_isMin_of_lt ← LT.lt.not_isMin
 
-alias not_isMax_of_lt ← LT.lt.not_is_max
+alias not_isMax_of_lt ← LT.lt.not_isMax
 
 theorem isMin_iff_forall_not_lt : IsMin a ↔ ∀ b, ¬b < a :=
   ⟨fun h _ => h.not_lt, fun h _ hba => of_not_not fun hab => h _ <| hba.lt_of_not_le hab⟩

c4658a64

feat: port Data.Pi.Lex (#1104)

mathlib3 SHA: d4f69d96

db9b53ae

Diff

@@ -9,6 +9,7 @@ Authors: Jeremy Avigad, Yury Kudryashov, Yaël Dillies
 ! if you have ported upstream changes.
 -/
 import Mathlib.Order.Synonym
+import Mathlib.Tactic.Classical
 
 /-!
 # Minimal/maximal and bottom/top elements
@@ -36,6 +37,8 @@ See also `isBot_iff_isMin` and `isTop_iff_isMax` for the equivalences in a (co)d
 
 open OrderDual
 
+universe u v
+
 variable {α β : Type _}
 
 /-- Order without bottom elements. -/
@@ -100,6 +103,44 @@ instance (priority := 100) [Preorder α] [NoMinOrder α] : NoBotOrder α :=
 instance (priority := 100) [Preorder α] [NoMaxOrder α] : NoTopOrder α :=
   ⟨fun a => (exists_gt a).imp fun _ => not_le_of_lt⟩
 
+instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α × β) :=
+  ⟨fun ⟨a, b⟩ => by
+    obtain ⟨c, h⟩ := exists_gt a
+    exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
+#align no_max_order_of_left noMaxOrder_of_left
+
+instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α × β) :=
+  ⟨fun ⟨a, b⟩ => by
+    obtain ⟨c, h⟩ := exists_gt b
+    exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
+#align no_max_order_of_right noMaxOrder_of_right
+
+instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α × β) :=
+  ⟨fun ⟨a, b⟩ => by
+    obtain ⟨c, h⟩ := exists_lt a
+    exact ⟨(c, b), Prod.mk_lt_mk_iff_left.2 h⟩⟩
+#align no_min_order_of_left noMinOrder_of_left
+
+instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α × β) :=
+  ⟨fun ⟨a, b⟩ => by
+    obtain ⟨c, h⟩ := exists_lt b
+    exact ⟨(a, c), Prod.mk_lt_mk_iff_right.2 h⟩⟩
+#align no_min_order_of_right noMinOrder_of_right
+
+instance {ι : Type u} {π : ι → Type _} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] :
+    NoMaxOrder (∀ i, π i) :=
+  ⟨fun a => by
+    classical
+    obtain ⟨b, hb⟩ := exists_gt (a <| Classical.arbitrary _)
+    exact ⟨_, lt_update_self_iff.2 hb⟩⟩
+
+instance {ι : Type u} {π : ι → Type _} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMinOrder (π i)] :
+    NoMinOrder (∀ i, π i) :=
+  ⟨fun a => by
+     classical
+      obtain ⟨b, hb⟩ := exists_lt (a <| Classical.arbitrary _)
+      exact ⟨_, update_lt_self_iff.2 hb⟩⟩
+
 -- Porting note: mathlib3 proof uses `convert`
 theorem NoBotOrder.to_noMinOrder (α : Type _) [LinearOrder α] [NoBotOrder α] : NoMinOrder α :=
   { exists_lt := fun a => by simpa [not_le] using exists_not_ge a }

c4658a64

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

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

f168625e

Diff

@@ -2,6 +2,11 @@
 Copyright (c) 2014 Jeremy Avigad. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Jeremy Avigad, Yury Kudryashov, Yaël Dillies
+
+! This file was ported from Lean 3 source module order.max
+! leanprover-community/mathlib commit c4658a649d216f57e99621708b09dcb3dcccbd23
+! Please do not edit these lines, except to modify the commit id
+! if you have ported upstream changes.
 -/
 import Mathlib.Order.Synonym

`order.max` ⟷ `Mathlib.Order.Max`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 15

order.max ⟷ Mathlib.Order.Max

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 15

`order.max` ⟷ `Mathlib.Order.Max`