order.succ_pred.basic ⟷ Mathlib.Order.SuccPred.Basic

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

@@ -668,7 +668,7 @@ theorem lt_succ_bot_iff [NoMaxOrder α] : a < succ ⊥ ↔ a = ⊥ := by rw [lt_
 
 #print Order.le_succ_bot_iff /-
 theorem le_succ_bot_iff : a ≤ succ ⊥ ↔ a = ⊥ ∨ a = succ ⊥ := by
-  rw [le_succ_iff_eq_or_le, le_bot_iff, or_comm']
+  rw [le_succ_iff_eq_or_le, le_bot_iff, or_comm]
 #align order.le_succ_bot_iff Order.le_succ_bot_iff
 -/
 

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

@@ -1233,7 +1233,7 @@ theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^
     (pred^[n]) ((succ^[n]) i) = i := by
   induction' n with n hn
   · simp only [Function.iterate_zero, id.def]
-  rw [Nat.succ_sub_succ_eq_sub, Nat.sub_zero] at hin 
+  rw [Nat.succ_sub_succ_eq_sub, Nat.sub_zero] at hin
   have h_not_max : ¬IsMax ((succ^[n - 1]) i) :=
     by
     cases n
@@ -1305,20 +1305,20 @@ instance : SuccOrder (WithTop α)
   max_of_succ_le a ha := by
     cases a
     · exact isMax_top
-    change ite _ _ _ ≤ _ at ha 
-    split_ifs at ha  with ha'
+    change ite _ _ _ ≤ _ at ha
+    split_ifs at ha with ha'
     · exact (not_top_le_coe _ ha).elim
-    · rw [some_le_some, succ_le_iff_eq_top] at ha 
+    · rw [some_le_some, succ_le_iff_eq_top] at ha
       exact (ha' ha).elim
   succ_le_of_lt a b h := by
     cases b
     · exact le_top
     cases a
     · exact (not_top_lt h).elim
-    rw [some_lt_some] at h 
+    rw [some_lt_some] at h
     change ite _ _ _ ≤ _
     split_ifs with ha
-    · rw [ha] at h 
+    · rw [ha] at h
       exact (not_top_lt h).elim
     · exact some_le_some.2 (succ_le_of_lt h)
   le_of_lt_succ a b h := by
@@ -1326,9 +1326,9 @@ instance : SuccOrder (WithTop α)
     · exact (not_top_lt h).elim
     cases b
     · exact le_top
-    change _ < ite _ _ _ at h 
+    change _ < ite _ _ _ at h
     rw [some_le_some]
-    split_ifs at h  with hb
+    split_ifs at h with hb
     · rw [hb]
       exact le_top
     · exact le_of_lt_succ (some_lt_some.1 h)
@@ -1461,7 +1461,7 @@ instance [hα : Nonempty α] : IsEmpty (PredOrder (WithTop α)) :=
     cases' h : pred (⊤ : WithTop α) with a ha
     · exact hα.elim fun a => (min_of_le_pred h.ge).not_lt <| coe_lt_top a
     · obtain ⟨c, hc⟩ := exists_gt a
-      rw [← some_lt_some, ← h] at hc 
+      rw [← some_lt_some, ← h] at hc
       exact (le_of_pred_lt hc).not_lt (some_lt_none _)⟩
 
 end Pred
@@ -1550,20 +1550,20 @@ instance : PredOrder (WithBot α)
   min_of_le_pred a ha := by
     cases a
     · exact isMin_bot
-    change _ ≤ ite _ _ _ at ha 
-    split_ifs at ha  with ha'
+    change _ ≤ ite _ _ _ at ha
+    split_ifs at ha with ha'
     · exact (not_coe_le_bot _ ha).elim
-    · rw [some_le_some, le_pred_iff_eq_bot] at ha 
+    · rw [some_le_some, le_pred_iff_eq_bot] at ha
       exact (ha' ha).elim
   le_pred_of_lt a b h := by
     cases a
     · exact bot_le
     cases b
     · exact (not_lt_bot h).elim
-    rw [some_lt_some] at h 
+    rw [some_lt_some] at h
     change _ ≤ ite _ _ _
     split_ifs with hb
-    · rw [hb] at h 
+    · rw [hb] at h
       exact (not_lt_bot h).elim
     · exact some_le_some.2 (le_pred_of_lt h)
   le_of_pred_lt a b h := by
@@ -1571,9 +1571,9 @@ instance : PredOrder (WithBot α)
     · exact (not_lt_bot h).elim
     cases a
     · exact bot_le
-    change ite _ _ _ < _ at h 
+    change ite _ _ _ < _ at h
     rw [some_le_some]
-    split_ifs at h  with ha
+    split_ifs at h with ha
     · rw [ha]
       exact bot_le
     · exact le_of_pred_lt (some_lt_some.1 h)
@@ -1606,7 +1606,7 @@ instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
     cases' h : succ (⊥ : WithBot α) with a ha
     · exact hα.elim fun a => (max_of_succ_le h.le).not_lt <| bot_lt_coe a
     · obtain ⟨c, hc⟩ := exists_lt a
-      rw [← some_lt_some, ← h] at hc 
+      rw [← some_lt_some, ← h] at hc
       exact (le_of_lt_succ hc).not_lt (none_lt_some _)⟩
 
 end Succ

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

@@ -250,16 +250,16 @@ theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a :=
 alias ⟨_, lt_succ_of_not_is_max⟩ := lt_succ_iff_not_is_max
 #align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMax
 
-#print Order.wcovby_succ /-
-theorem wcovby_succ (a : α) : a ⩿ succ a :=
+#print Order.wcovBy_succ /-
+theorem wcovBy_succ (a : α) : a ⩿ succ a :=
   ⟨le_succ a, fun b hb => (succ_le_of_lt hb).not_lt⟩
-#align order.wcovby_succ Order.wcovby_succ
+#align order.wcovby_succ Order.wcovBy_succ
 -/
 
-#print Order.covby_succ_of_not_isMax /-
-theorem covby_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a :=
-  (wcovby_succ a).covby_of_lt <| lt_succ_of_not_isMax h
-#align order.covby_succ_of_not_is_max Order.covby_succ_of_not_isMax
+#print Order.covBy_succ_of_not_isMax /-
+theorem covBy_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a :=
+  (wcovBy_succ a).covBy_of_lt <| lt_succ_of_not_isMax h
+#align order.covby_succ_of_not_is_max Order.covBy_succ_of_not_isMax
 -/
 
 #print Order.lt_succ_iff_of_not_isMax /-
@@ -416,10 +416,10 @@ theorem succ_strictMono : StrictMono (succ : α → α) := fun a b => succ_lt_su
 #align order.succ_strict_mono Order.succ_strictMono
 -/
 
-#print Order.covby_succ /-
-theorem covby_succ (a : α) : a ⋖ succ a :=
-  covby_succ_of_not_isMax <| not_isMax a
-#align order.covby_succ Order.covby_succ
+#print Order.covBy_succ /-
+theorem covBy_succ (a : α) : a ⋖ succ a :=
+  covBy_succ_of_not_isMax <| not_isMax a
+#align order.covby_succ Order.covBy_succ
 -/
 
 #print Order.Iio_succ /-
@@ -504,19 +504,19 @@ theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
 #align order.le_le_succ_iff Order.le_le_succ_iff
 -/
 
-#print Covby.succ_eq /-
-theorem Covby.succ_eq (h : a ⋖ b) : succ a = b :=
+#print CovBy.succ_eq /-
+theorem CovBy.succ_eq (h : a ⋖ b) : succ a = b :=
   (succ_le_of_lt h.lt).eq_of_not_lt fun h' => h.2 (lt_succ_of_not_isMax h.lt.not_isMax) h'
-#align covby.succ_eq Covby.succ_eq
+#align covby.succ_eq CovBy.succ_eq
 -/
 
-#print Wcovby.le_succ /-
-theorem Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a :=
+#print WCovBy.le_succ /-
+theorem WCovBy.le_succ (h : a ⩿ b) : b ≤ succ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.succ_eq.ge
   · exact le_succ _
-#align wcovby.le_succ Wcovby.le_succ
+#align wcovby.le_succ WCovBy.le_succ
 -/
 
 #print Order.le_succ_iff_eq_or_le /-
@@ -603,10 +603,10 @@ theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b :=
 #align order.lt_succ_iff_eq_or_lt Order.lt_succ_iff_eq_or_lt
 -/
 
-#print Order.succ_eq_iff_covby /-
-theorem succ_eq_iff_covby : succ a = b ↔ a ⋖ b :=
-  ⟨by rintro rfl; exact covby_succ _, Covby.succ_eq⟩
-#align order.succ_eq_iff_covby Order.succ_eq_iff_covby
+#print Order.succ_eq_iff_covBy /-
+theorem succ_eq_iff_covBy : succ a = b ↔ a ⋖ b :=
+  ⟨by rintro rfl; exact covby_succ _, CovBy.succ_eq⟩
+#align order.succ_eq_iff_covby Order.succ_eq_iff_covBy
 -/
 
 #print Order.Iio_succ_eq_insert /-
@@ -697,7 +697,7 @@ instance [PartialOrder α] : Subsingleton (SuccOrder α) :=
     ext a
     by_cases ha : IsMax a
     · exact (@IsMax.succ_eq _ _ h₀ _ ha).trans ha.succ_eq.symm
-    · exact @Covby.succ_eq _ _ h₀ _ _ (covby_succ_of_not_is_max ha)⟩
+    · exact @CovBy.succ_eq _ _ h₀ _ _ (covby_succ_of_not_is_max ha)⟩
 
 section CompleteLattice
 
@@ -772,16 +772,16 @@ theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a :=
 alias ⟨_, pred_lt_of_not_is_min⟩ := pred_lt_iff_not_is_min
 #align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMin
 
-#print Order.pred_wcovby /-
-theorem pred_wcovby (a : α) : pred a ⩿ a :=
+#print Order.pred_wcovBy /-
+theorem pred_wcovBy (a : α) : pred a ⩿ a :=
   ⟨pred_le a, fun b hb => (le_of_pred_lt hb).not_lt⟩
-#align order.pred_wcovby Order.pred_wcovby
+#align order.pred_wcovby Order.pred_wcovBy
 -/
 
-#print Order.pred_covby_of_not_isMin /-
-theorem pred_covby_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a :=
-  (pred_wcovby a).covby_of_lt <| pred_lt_of_not_isMin h
-#align order.pred_covby_of_not_is_min Order.pred_covby_of_not_isMin
+#print Order.pred_covBy_of_not_isMin /-
+theorem pred_covBy_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a :=
+  (pred_wcovBy a).covBy_of_lt <| pred_lt_of_not_isMin h
+#align order.pred_covby_of_not_is_min Order.pred_covBy_of_not_isMin
 -/
 
 #print Order.pred_lt_iff_of_not_isMin /-
@@ -912,10 +912,10 @@ theorem pred_strictMono : StrictMono (pred : α → α) := fun a b => pred_lt_pr
 #align order.pred_strict_mono Order.pred_strictMono
 -/
 
-#print Order.pred_covby /-
-theorem pred_covby (a : α) : pred a ⋖ a :=
-  pred_covby_of_not_isMin <| not_isMin a
-#align order.pred_covby Order.pred_covby
+#print Order.pred_covBy /-
+theorem pred_covBy (a : α) : pred a ⋖ a :=
+  pred_covBy_of_not_isMin <| not_isMin a
+#align order.pred_covby Order.pred_covBy
 -/
 
 #print Order.Ioi_pred /-
@@ -992,19 +992,19 @@ theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = p
 #align order.pred_le_le_iff Order.pred_le_le_iff
 -/
 
-#print Covby.pred_eq /-
-theorem Covby.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
+#print CovBy.pred_eq /-
+theorem CovBy.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
   (le_pred_of_lt h.lt).eq_of_not_gt fun h' => h.2 h' <| pred_lt_of_not_isMin h.lt.not_isMin
-#align covby.pred_eq Covby.pred_eq
+#align covby.pred_eq CovBy.pred_eq
 -/
 
-#print Wcovby.pred_le /-
-theorem Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a :=
+#print WCovBy.pred_le /-
+theorem WCovBy.pred_le (h : a ⩿ b) : pred b ≤ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.pred_eq.le
   · exact pred_le _
-#align wcovby.pred_le Wcovby.pred_le
+#align wcovby.pred_le WCovBy.pred_le
 -/
 
 #print Order.pred_le_iff_eq_or_le /-
@@ -1079,10 +1079,10 @@ theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b :=
 #align order.pred_lt_iff_eq_or_lt Order.pred_lt_iff_eq_or_lt
 -/
 
-#print Order.pred_eq_iff_covby /-
-theorem pred_eq_iff_covby : pred b = a ↔ a ⋖ b :=
-  ⟨by rintro rfl; exact pred_covby _, Covby.pred_eq⟩
-#align order.pred_eq_iff_covby Order.pred_eq_iff_covby
+#print Order.pred_eq_iff_covBy /-
+theorem pred_eq_iff_covBy : pred b = a ↔ a ⋖ b :=
+  ⟨by rintro rfl; exact pred_covby _, CovBy.pred_eq⟩
+#align order.pred_eq_iff_covby Order.pred_eq_iff_covBy
 -/
 
 #print Order.Ioi_pred_eq_insert /-
@@ -1174,7 +1174,7 @@ instance [PartialOrder α] : Subsingleton (PredOrder α) :=
     ext a
     by_cases ha : IsMin a
     · exact (@IsMin.pred_eq _ _ h₀ _ ha).trans ha.pred_eq.symm
-    · exact @Covby.pred_eq _ _ h₀ _ _ (pred_covby_of_not_is_min ha)⟩
+    · exact @CovBy.pred_eq _ _ h₀ _ _ (pred_covby_of_not_is_min ha)⟩
 
 section CompleteLattice
 
@@ -1203,28 +1203,28 @@ variable [PartialOrder α] [SuccOrder α] [PredOrder α] {a b : α}
 #print Order.succ_pred_of_not_isMin /-
 @[simp]
 theorem succ_pred_of_not_isMin (h : ¬IsMin a) : succ (pred a) = a :=
-  (pred_covby_of_not_isMin h).succ_eq
+  (pred_covBy_of_not_isMin h).succ_eq
 #align order.succ_pred_of_not_is_min Order.succ_pred_of_not_isMin
 -/
 
 #print Order.pred_succ_of_not_isMax /-
 @[simp]
 theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a :=
-  (covby_succ_of_not_isMax h).pred_eq
+  (covBy_succ_of_not_isMax h).pred_eq
 #align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMax
 -/
 
 #print Order.succ_pred /-
 @[simp]
 theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a :=
-  (pred_covby _).succ_eq
+  (pred_covBy _).succ_eq
 #align order.succ_pred Order.succ_pred
 -/
 
 #print Order.pred_succ /-
 @[simp]
 theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
-  (covby_succ _).pred_eq
+  (covBy_succ _).pred_eq
 #align order.pred_succ Order.pred_succ
 -/
 

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

@@ -495,7 +495,7 @@ theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
   by
   refine'
     ⟨fun h =>
-      or_iff_not_imp_left.2 fun hba : b ≠ a =>
+      Classical.or_iff_not_imp_left.2 fun hba : b ≠ a =>
         h.2.antisymm (succ_le_of_lt <| h.1.lt_of_ne <| hba.symm),
       _⟩
   rintro (rfl | rfl)
@@ -983,7 +983,9 @@ theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = p
   by
   refine'
     ⟨fun h =>
-      or_iff_not_imp_left.2 fun hba : b ≠ a => (le_pred_of_lt <| h.2.lt_of_ne hba).antisymm h.1, _⟩
+      Classical.or_iff_not_imp_left.2 fun hba : b ≠ a =>
+        (le_pred_of_lt <| h.2.lt_of_ne hba).antisymm h.1,
+      _⟩
   rintro (rfl | rfl)
   · exact ⟨pred_le b, le_rfl⟩
   · exact ⟨le_rfl, pred_le a⟩

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

@@ -3,9 +3,9 @@ Copyright (c) 2021 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 -/
-import Mathbin.Order.CompleteLattice
-import Mathbin.Order.Cover
-import Mathbin.Order.Iterate
+import Order.CompleteLattice
+import Order.Cover
+import Order.Iterate
 
 #align_import order.succ_pred.basic from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
 

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

@@ -247,7 +247,7 @@ theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a :=
 #align order.lt_succ_iff_not_is_max Order.lt_succ_iff_not_isMax
 -/
 
-alias lt_succ_iff_not_is_max ↔ _ lt_succ_of_not_is_max
+alias ⟨_, lt_succ_of_not_is_max⟩ := lt_succ_iff_not_is_max
 #align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMax
 
 #print Order.wcovby_succ /-
@@ -404,10 +404,10 @@ theorem succ_lt_succ_iff : succ a < succ b ↔ a < b := by simp
 #align order.succ_lt_succ_iff Order.succ_lt_succ_iff
 -/
 
-alias succ_le_succ_iff ↔ le_of_succ_le_succ _
+alias ⟨le_of_succ_le_succ, _⟩ := succ_le_succ_iff
 #align order.le_of_succ_le_succ Order.le_of_succ_le_succ
 
-alias succ_lt_succ_iff ↔ lt_of_succ_lt_succ succ_lt_succ
+alias ⟨lt_of_succ_lt_succ, succ_lt_succ⟩ := succ_lt_succ_iff
 #align order.lt_of_succ_lt_succ Order.lt_of_succ_lt_succ
 #align order.succ_lt_succ Order.succ_lt_succ
 
@@ -479,7 +479,7 @@ theorem succ_eq_iff_isMax : succ a = a ↔ IsMax a :=
 #align order.succ_eq_iff_is_max Order.succ_eq_iff_isMax
 -/
 
-alias succ_eq_iff_is_max ↔ _ _root_.is_max.succ_eq
+alias ⟨_, _root_.is_max.succ_eq⟩ := succ_eq_iff_is_max
 #align is_max.succ_eq IsMax.succ_eq
 
 #print Order.succ_eq_succ_iff_of_not_isMax /-
@@ -594,7 +594,7 @@ theorem succ_ne_succ_iff : succ a ≠ succ b ↔ a ≠ b :=
 #align order.succ_ne_succ_iff Order.succ_ne_succ_iff
 -/
 
-alias succ_ne_succ_iff ↔ _ succ_ne_succ
+alias ⟨_, succ_ne_succ⟩ := succ_ne_succ_iff
 #align order.succ_ne_succ Order.succ_ne_succ
 
 #print Order.lt_succ_iff_eq_or_lt /-
@@ -769,7 +769,7 @@ theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a :=
 #align order.pred_lt_iff_not_is_min Order.pred_lt_iff_not_isMin
 -/
 
-alias pred_lt_iff_not_is_min ↔ _ pred_lt_of_not_is_min
+alias ⟨_, pred_lt_of_not_is_min⟩ := pred_lt_iff_not_is_min
 #align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMin
 
 #print Order.pred_wcovby /-
@@ -900,10 +900,10 @@ theorem pred_lt_pred_iff : pred a < pred b ↔ a < b := by simp
 #align order.pred_lt_pred_iff Order.pred_lt_pred_iff
 -/
 
-alias pred_le_pred_iff ↔ le_of_pred_le_pred _
+alias ⟨le_of_pred_le_pred, _⟩ := pred_le_pred_iff
 #align order.le_of_pred_le_pred Order.le_of_pred_le_pred
 
-alias pred_lt_pred_iff ↔ lt_of_pred_lt_pred pred_lt_pred
+alias ⟨lt_of_pred_lt_pred, pred_lt_pred⟩ := pred_lt_pred_iff
 #align order.lt_of_pred_lt_pred Order.lt_of_pred_lt_pred
 #align order.pred_lt_pred Order.pred_lt_pred
 
@@ -975,7 +975,7 @@ theorem pred_eq_iff_isMin : pred a = a ↔ IsMin a :=
 #align order.pred_eq_iff_is_min Order.pred_eq_iff_isMin
 -/
 
-alias pred_eq_iff_is_min ↔ _ _root_.is_min.pred_eq
+alias ⟨_, _root_.is_min.pred_eq⟩ := pred_eq_iff_is_min
 #align is_min.pred_eq IsMin.pred_eq
 
 #print Order.pred_le_le_iff /-
@@ -1068,7 +1068,7 @@ theorem pred_ne_pred_iff : pred a ≠ pred b ↔ a ≠ b :=
 #align order.pred_ne_pred_iff Order.pred_ne_pred_iff
 -/
 
-alias pred_ne_pred_iff ↔ _ pred_ne_pred
+alias ⟨_, pred_ne_pred⟩ := pred_ne_pred_iff
 #align order.pred_ne_pred Order.pred_ne_pred
 
 #print Order.pred_lt_iff_eq_or_lt /-

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

@@ -2,16 +2,13 @@
 Copyright (c) 2021 Yaël Dillies. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
-
-! This file was ported from Lean 3 source module order.succ_pred.basic
-! leanprover-community/mathlib commit 0111834459f5d7400215223ea95ae38a1265a907
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.CompleteLattice
 import Mathbin.Order.Cover
 import Mathbin.Order.Iterate
 
+#align_import order.succ_pred.basic from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
+
 /-!
 # Successor and predecessor
 

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

@@ -636,20 +636,26 @@ section OrderTop
 
 variable [OrderTop α]
 
+#print Order.succ_top /-
 @[simp]
 theorem succ_top : succ (⊤ : α) = ⊤ :=
   isMax_top.succ_eq
 #align order.succ_top Order.succ_top
+-/
 
+#print Order.succ_le_iff_eq_top /-
 @[simp]
 theorem succ_le_iff_eq_top : succ a ≤ a ↔ a = ⊤ :=
   succ_le_iff_isMax.trans isMax_iff_eq_top
 #align order.succ_le_iff_eq_top Order.succ_le_iff_eq_top
+-/
 
+#print Order.lt_succ_iff_ne_top /-
 @[simp]
 theorem lt_succ_iff_ne_top : a < succ a ↔ a ≠ ⊤ :=
   lt_succ_iff_not_isMax.trans not_isMax_iff_ne_top
 #align order.lt_succ_iff_ne_top Order.lt_succ_iff_ne_top
+-/
 
 end OrderTop
 
@@ -657,23 +663,31 @@ section OrderBot
 
 variable [OrderBot α]
 
+#print Order.lt_succ_bot_iff /-
 @[simp]
 theorem lt_succ_bot_iff [NoMaxOrder α] : a < succ ⊥ ↔ a = ⊥ := by rw [lt_succ_iff, le_bot_iff]
 #align order.lt_succ_bot_iff Order.lt_succ_bot_iff
+-/
 
+#print Order.le_succ_bot_iff /-
 theorem le_succ_bot_iff : a ≤ succ ⊥ ↔ a = ⊥ ∨ a = succ ⊥ := by
   rw [le_succ_iff_eq_or_le, le_bot_iff, or_comm']
 #align order.le_succ_bot_iff Order.le_succ_bot_iff
+-/
 
 variable [Nontrivial α]
 
+#print Order.bot_lt_succ /-
 theorem bot_lt_succ (a : α) : ⊥ < succ a :=
   (lt_succ_of_not_isMax not_isMax_bot).trans_le <| succ_mono bot_le
 #align order.bot_lt_succ Order.bot_lt_succ
+-/
 
+#print Order.succ_ne_bot /-
 theorem succ_ne_bot (a : α) : succ a ≠ ⊥ :=
   (bot_lt_succ a).ne'
 #align order.succ_ne_bot Order.succ_ne_bot
+-/
 
 end OrderBot
 
@@ -692,6 +706,7 @@ section CompleteLattice
 
 variable [CompleteLattice α] [SuccOrder α]
 
+#print Order.succ_eq_iInf /-
 theorem succ_eq_iInf (a : α) : succ a = ⨅ (b) (h : a < b), b :=
   by
   refine' le_antisymm (le_iInf fun b => le_iInf succ_le_of_lt) _
@@ -700,6 +715,7 @@ theorem succ_eq_iInf (a : α) : succ a = ⨅ (b) (h : a < b), b :=
     exact le_top
   exact iInf₂_le _ (lt_succ_iff_ne_top.2 ha)
 #align order.succ_eq_infi Order.succ_eq_iInf
+-/
 
 end CompleteLattice
 
@@ -1094,20 +1110,26 @@ section OrderBot
 
 variable [OrderBot α]
 
+#print Order.pred_bot /-
 @[simp]
 theorem pred_bot : pred (⊥ : α) = ⊥ :=
   isMin_bot.pred_eq
 #align order.pred_bot Order.pred_bot
+-/
 
+#print Order.le_pred_iff_eq_bot /-
 @[simp]
 theorem le_pred_iff_eq_bot : a ≤ pred a ↔ a = ⊥ :=
   @succ_le_iff_eq_top αᵒᵈ _ _ _ _
 #align order.le_pred_iff_eq_bot Order.le_pred_iff_eq_bot
+-/
 
+#print Order.pred_lt_iff_ne_bot /-
 @[simp]
 theorem pred_lt_iff_ne_bot : pred a < a ↔ a ≠ ⊥ :=
   @lt_succ_iff_ne_top αᵒᵈ _ _ _ _
 #align order.pred_lt_iff_ne_bot Order.pred_lt_iff_ne_bot
+-/
 
 end OrderBot
 
@@ -1115,24 +1137,32 @@ section OrderTop
 
 variable [OrderTop α]
 
+#print Order.pred_top_lt_iff /-
 @[simp]
 theorem pred_top_lt_iff [NoMinOrder α] : pred ⊤ < a ↔ a = ⊤ :=
   @lt_succ_bot_iff αᵒᵈ _ _ _ _ _
 #align order.pred_top_lt_iff Order.pred_top_lt_iff
+-/
 
+#print Order.pred_top_le_iff /-
 theorem pred_top_le_iff : pred ⊤ ≤ a ↔ a = ⊤ ∨ a = pred ⊤ :=
   @le_succ_bot_iff αᵒᵈ _ _ _ _
 #align order.pred_top_le_iff Order.pred_top_le_iff
+-/
 
 variable [Nontrivial α]
 
+#print Order.pred_lt_top /-
 theorem pred_lt_top (a : α) : pred a < ⊤ :=
   (pred_mono le_top).trans_lt <| pred_lt_of_not_isMin not_isMin_top
 #align order.pred_lt_top Order.pred_lt_top
+-/
 
+#print Order.pred_ne_top /-
 theorem pred_ne_top (a : α) : pred a ≠ ⊤ :=
   (pred_lt_top a).Ne
 #align order.pred_ne_top Order.pred_ne_top
+-/
 
 end OrderTop
 
@@ -1151,6 +1181,7 @@ section CompleteLattice
 
 variable [CompleteLattice α] [PredOrder α]
 
+#print Order.pred_eq_iSup /-
 theorem pred_eq_iSup (a : α) : pred a = ⨆ (b) (h : b < a), b :=
   by
   refine' le_antisymm _ (iSup_le fun b => iSup_le le_pred_of_lt)
@@ -1159,6 +1190,7 @@ theorem pred_eq_iSup (a : α) : pred a = ⨆ (b) (h : b < a), b :=
     exact bot_le
   · exact @le_iSup₂ _ _ (fun b => b < a) _ (fun a _ => a) (pred a) (pred_lt_iff_ne_bot.2 ha)
 #align order.pred_eq_supr Order.pred_eq_iSup
+-/
 
 end CompleteLattice
 
@@ -1302,14 +1334,18 @@ instance : SuccOrder (WithTop α)
       exact le_top
     · exact le_of_lt_succ (some_lt_some.1 h)
 
+#print WithTop.succ_coe_top /-
 @[simp]
 theorem succ_coe_top : succ ↑(⊤ : α) = (⊤ : WithTop α) :=
   dif_pos rfl
 #align with_top.succ_coe_top WithTop.succ_coe_top
+-/
 
+#print WithTop.succ_coe_of_ne_top /-
 theorem succ_coe_of_ne_top {a : α} (h : a ≠ ⊤) : succ (↑a : WithTop α) = ↑(succ a) :=
   dif_neg h
 #align with_top.succ_coe_of_ne_top WithTop.succ_coe_of_ne_top
+-/
 
 end Succ
 
@@ -1344,10 +1380,12 @@ instance : PredOrder (WithTop α)
     · exact (not_top_lt <| some_lt_some.1 h).elim
     · exact some_le_some.2 (le_of_pred_lt <| some_lt_some.1 h)
 
+#print WithTop.pred_top /-
 @[simp]
 theorem pred_top : pred (⊤ : WithTop α) = ↑(⊤ : α) :=
   rfl
 #align with_top.pred_top WithTop.pred_top
+-/
 
 #print WithTop.pred_coe /-
 @[simp]
@@ -1356,6 +1394,7 @@ theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
 #align with_top.pred_coe WithTop.pred_coe
 -/
 
+#print WithTop.pred_untop /-
 @[simp]
 theorem pred_untop :
     ∀ (a : WithTop α) (ha : a ≠ ⊤),
@@ -1363,6 +1402,7 @@ theorem pred_untop :
   | ⊤, ha => (ha rfl).elim
   | (a : α), ha => rfl
 #align with_top.pred_untop WithTop.pred_untop
+-/
 
 end Pred
 
@@ -1465,10 +1505,12 @@ instance : SuccOrder (WithBot α)
     · exact (not_lt_bot <| some_lt_some.1 h).elim
     · exact some_le_some.2 (le_of_lt_succ <| some_lt_some.1 h)
 
+#print WithBot.succ_bot /-
 @[simp]
 theorem succ_bot : succ (⊥ : WithBot α) = ↑(⊥ : α) :=
   rfl
 #align with_bot.succ_bot WithBot.succ_bot
+-/
 
 #print WithBot.succ_coe /-
 @[simp]
@@ -1477,6 +1519,7 @@ theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
 #align with_bot.succ_coe WithBot.succ_coe
 -/
 
+#print WithBot.succ_unbot /-
 @[simp]
 theorem succ_unbot :
     ∀ (a : WithBot α) (ha : a ≠ ⊥),
@@ -1484,6 +1527,7 @@ theorem succ_unbot :
   | ⊥, ha => (ha rfl).elim
   | (a : α), ha => rfl
 #align with_bot.succ_unbot WithBot.succ_unbot
+-/
 
 end Succ
 
@@ -1535,14 +1579,18 @@ instance : PredOrder (WithBot α)
       exact bot_le
     · exact le_of_pred_lt (some_lt_some.1 h)
 
+#print WithBot.pred_coe_bot /-
 @[simp]
 theorem pred_coe_bot : pred ↑(⊥ : α) = (⊥ : WithBot α) :=
   dif_pos rfl
 #align with_bot.pred_coe_bot WithBot.pred_coe_bot
+-/
 
+#print WithBot.pred_coe_of_ne_bot /-
 theorem pred_coe_of_ne_bot {a : α} (h : a ≠ ⊥) : pred (↑a : WithBot α) = ↑(pred a) :=
   dif_neg h
 #align with_bot.pred_coe_of_ne_bot WithBot.pred_coe_of_ne_bot
+-/
 
 end Pred
 
@@ -1793,9 +1841,11 @@ section OrderBot
 
 variable [Preorder α] [OrderBot α] [SuccOrder α] [IsSuccArchimedean α]
 
+#print Succ.rec_bot /-
 theorem Succ.rec_bot (p : α → Prop) (hbot : p ⊥) (hsucc : ∀ a, p a → p (succ a)) (a : α) : p a :=
   Succ.rec hbot (fun x _ h => hsucc x h) (bot_le : ⊥ ≤ a)
 #align succ.rec_bot Succ.rec_bot
+-/
 
 end OrderBot
 
@@ -1803,9 +1853,11 @@ section OrderTop
 
 variable [Preorder α] [OrderTop α] [PredOrder α] [IsPredArchimedean α]
 
+#print Pred.rec_top /-
 theorem Pred.rec_top (p : α → Prop) (htop : p ⊤) (hpred : ∀ a, p a → p (pred a)) (a : α) : p a :=
   Pred.rec htop (fun x _ h => hpred x h) (le_top : a ≤ ⊤)
 #align pred.rec_top Pred.rec_top
+-/
 
 end OrderTop
 

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

@@ -1275,7 +1275,7 @@ instance : SuccOrder (WithTop α)
     cases a
     · exact isMax_top
     change ite _ _ _ ≤ _ at ha 
-    split_ifs  at ha  with ha'
+    split_ifs at ha  with ha'
     · exact (not_top_le_coe _ ha).elim
     · rw [some_le_some, succ_le_iff_eq_top] at ha 
       exact (ha' ha).elim
@@ -1297,7 +1297,7 @@ instance : SuccOrder (WithTop α)
     · exact le_top
     change _ < ite _ _ _ at h 
     rw [some_le_some]
-    split_ifs  at h  with hb
+    split_ifs at h  with hb
     · rw [hb]
       exact le_top
     · exact le_of_lt_succ (some_lt_some.1 h)
@@ -1508,7 +1508,7 @@ instance : PredOrder (WithBot α)
     cases a
     · exact isMin_bot
     change _ ≤ ite _ _ _ at ha 
-    split_ifs  at ha  with ha'
+    split_ifs at ha  with ha'
     · exact (not_coe_le_bot _ ha).elim
     · rw [some_le_some, le_pred_iff_eq_bot] at ha 
       exact (ha' ha).elim
@@ -1530,7 +1530,7 @@ instance : PredOrder (WithBot α)
     · exact bot_le
     change ite _ _ _ < _ at h 
     rw [some_le_some]
-    split_ifs  at h  with ha
+    split_ifs at h  with ha
     · rw [ha]
       exact bot_le
     · exact le_of_pred_lt (some_lt_some.1 h)
@@ -1783,7 +1783,7 @@ instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (
 
 #print IsWellOrder.toIsSuccArchimedean /-
 instance (priority := 100) IsWellOrder.toIsSuccArchimedean [h : IsWellOrder α (· > ·)]
-    [SuccOrder α] : IsSuccArchimedean α := by convert@OrderDual.isSuccArchimedean αᵒᵈ _ _ _
+    [SuccOrder α] : IsSuccArchimedean α := by convert @OrderDual.isSuccArchimedean αᵒᵈ _ _ _
 #align is_well_order.to_is_succ_archimedean IsWellOrder.toIsSuccArchimedean
 -/
 

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

@@ -1202,12 +1202,12 @@ theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^
     (pred^[n]) ((succ^[n]) i) = i := by
   induction' n with n hn
   · simp only [Function.iterate_zero, id.def]
-  rw [Nat.succ_sub_succ_eq_sub, Nat.sub_zero] at hin
+  rw [Nat.succ_sub_succ_eq_sub, Nat.sub_zero] at hin 
   have h_not_max : ¬IsMax ((succ^[n - 1]) i) :=
     by
     cases n
     · simpa using hin
-    rw [Nat.succ_sub_succ_eq_sub, Nat.sub_zero] at hn⊢
+    rw [Nat.succ_sub_succ_eq_sub, Nat.sub_zero] at hn ⊢
     have h_sub_le : (succ^[n]) i ≤ (succ^[n.succ]) i :=
       by
       rw [Function.iterate_succ']
@@ -1274,20 +1274,20 @@ instance : SuccOrder (WithTop α)
   max_of_succ_le a ha := by
     cases a
     · exact isMax_top
-    change ite _ _ _ ≤ _ at ha
-    split_ifs  at ha with ha'
+    change ite _ _ _ ≤ _ at ha 
+    split_ifs  at ha  with ha'
     · exact (not_top_le_coe _ ha).elim
-    · rw [some_le_some, succ_le_iff_eq_top] at ha
+    · rw [some_le_some, succ_le_iff_eq_top] at ha 
       exact (ha' ha).elim
   succ_le_of_lt a b h := by
     cases b
     · exact le_top
     cases a
     · exact (not_top_lt h).elim
-    rw [some_lt_some] at h
+    rw [some_lt_some] at h 
     change ite _ _ _ ≤ _
     split_ifs with ha
-    · rw [ha] at h
+    · rw [ha] at h 
       exact (not_top_lt h).elim
     · exact some_le_some.2 (succ_le_of_lt h)
   le_of_lt_succ a b h := by
@@ -1295,9 +1295,9 @@ instance : SuccOrder (WithTop α)
     · exact (not_top_lt h).elim
     cases b
     · exact le_top
-    change _ < ite _ _ _ at h
+    change _ < ite _ _ _ at h 
     rw [some_le_some]
-    split_ifs  at h with hb
+    split_ifs  at h  with hb
     · rw [hb]
       exact le_top
     · exact le_of_lt_succ (some_lt_some.1 h)
@@ -1422,7 +1422,7 @@ instance [hα : Nonempty α] : IsEmpty (PredOrder (WithTop α)) :=
     cases' h : pred (⊤ : WithTop α) with a ha
     · exact hα.elim fun a => (min_of_le_pred h.ge).not_lt <| coe_lt_top a
     · obtain ⟨c, hc⟩ := exists_gt a
-      rw [← some_lt_some, ← h] at hc
+      rw [← some_lt_some, ← h] at hc 
       exact (le_of_pred_lt hc).not_lt (some_lt_none _)⟩
 
 end Pred
@@ -1507,20 +1507,20 @@ instance : PredOrder (WithBot α)
   min_of_le_pred a ha := by
     cases a
     · exact isMin_bot
-    change _ ≤ ite _ _ _ at ha
-    split_ifs  at ha with ha'
+    change _ ≤ ite _ _ _ at ha 
+    split_ifs  at ha  with ha'
     · exact (not_coe_le_bot _ ha).elim
-    · rw [some_le_some, le_pred_iff_eq_bot] at ha
+    · rw [some_le_some, le_pred_iff_eq_bot] at ha 
       exact (ha' ha).elim
   le_pred_of_lt a b h := by
     cases a
     · exact bot_le
     cases b
     · exact (not_lt_bot h).elim
-    rw [some_lt_some] at h
+    rw [some_lt_some] at h 
     change _ ≤ ite _ _ _
     split_ifs with hb
-    · rw [hb] at h
+    · rw [hb] at h 
       exact (not_lt_bot h).elim
     · exact some_le_some.2 (le_pred_of_lt h)
   le_of_pred_lt a b h := by
@@ -1528,9 +1528,9 @@ instance : PredOrder (WithBot α)
     · exact (not_lt_bot h).elim
     cases a
     · exact bot_le
-    change ite _ _ _ < _ at h
+    change ite _ _ _ < _ at h 
     rw [some_le_some]
-    split_ifs  at h with ha
+    split_ifs  at h  with ha
     · rw [ha]
       exact bot_le
     · exact le_of_pred_lt (some_lt_some.1 h)
@@ -1559,7 +1559,7 @@ instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) :=
     cases' h : succ (⊥ : WithBot α) with a ha
     · exact hα.elim fun a => (max_of_succ_le h.le).not_lt <| bot_lt_coe a
     · obtain ⟨c, hc⟩ := exists_lt a
-      rw [← some_lt_some, ← h] at hc
+      rw [← some_lt_some, ← h] at hc 
       exact (le_of_lt_succ hc).not_lt (none_lt_some _)⟩
 
 end Succ

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

@@ -108,6 +108,7 @@ section Preorder
 
 variable [Preorder α]
 
+#print SuccOrder.ofSuccLeIffOfLeLtSucc /-
 /-- A constructor for `succ_order α` usable when `α` has no maximal element. -/
 def SuccOrder.ofSuccLeIffOfLeLtSucc (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b)
     (hle_of_lt_succ : ∀ {a b}, a < succ b → a ≤ b) : SuccOrder α :=
@@ -117,7 +118,9 @@ def SuccOrder.ofSuccLeIffOfLeLtSucc (succ : α → α) (hsucc_le_iff : ∀ {a b}
     succ_le_of_lt := fun a b => hsucc_le_iff.2
     le_of_lt_succ := fun a b => hle_of_lt_succ }
 #align succ_order.of_succ_le_iff_of_le_lt_succ SuccOrder.ofSuccLeIffOfLeLtSucc
+-/
 
+#print PredOrder.ofLePredIffOfPredLePred /-
 /-- A constructor for `pred_order α` usable when `α` has no minimal element. -/
 def PredOrder.ofLePredIffOfPredLePred (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b)
     (hle_of_pred_lt : ∀ {a b}, pred a < b → a ≤ b) : PredOrder α :=
@@ -127,6 +130,7 @@ def PredOrder.ofLePredIffOfPredLePred (pred : α → α) (hle_pred_iff : ∀ {a
     le_pred_of_lt := fun a b => hle_pred_iff.2
     le_of_pred_lt := fun a b => hle_of_pred_lt }
 #align pred_order.of_le_pred_iff_of_pred_le_pred PredOrder.ofLePredIffOfPredLePred
+-/
 
 end Preorder
 
@@ -134,6 +138,7 @@ section LinearOrder
 
 variable [LinearOrder α]
 
+#print SuccOrder.ofCore /-
 /-- A constructor for `succ_order α` for `α` a linear order. -/
 @[simps]
 def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a < b ↔ succ a ≤ b)
@@ -146,7 +151,9 @@ def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a <
       by_cases (fun h => hm b h ▸ hab.le) fun h => by simpa [hab] using (hn h a).Not
     max_of_succ_le := fun a => not_imp_not.mp fun h => by simpa using (hn h a).Not }
 #align succ_order.of_core SuccOrder.ofCore
+-/
 
+#print PredOrder.ofCore /-
 /-- A constructor for `pred_order α` for `α` a linear order. -/
 @[simps]
 def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
@@ -160,7 +167,9 @@ def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
       by_cases (fun h => hm a h ▸ hab.le) fun h => by simpa [hab] using (hn h b).Not
     min_of_le_pred := fun a => not_imp_not.mp fun h => by simpa using (hn h a).Not }
 #align pred_order.of_core PredOrder.ofCore
+-/
 
+#print SuccOrder.ofSuccLeIff /-
 /-- A constructor for `succ_order α` usable when `α` is a linear order with no maximal element. -/
 def SuccOrder.ofSuccLeIff (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b) :
     SuccOrder α :=
@@ -170,7 +179,9 @@ def SuccOrder.ofSuccLeIff (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a 
     succ_le_of_lt := fun a b => hsucc_le_iff.2
     le_of_lt_succ := fun a b h => le_of_not_lt ((not_congr hsucc_le_iff).1 h.not_le) }
 #align succ_order.of_succ_le_iff SuccOrder.ofSuccLeIff
+-/
 
+#print PredOrder.ofLePredIff /-
 /-- A constructor for `pred_order α` usable when `α` is a linear order with no minimal element. -/
 def PredOrder.ofLePredIff (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b) :
     PredOrder α :=
@@ -180,6 +191,7 @@ def PredOrder.ofLePredIff (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pr
     le_pred_of_lt := fun a b => hle_pred_iff.2
     le_of_pred_lt := fun a b h => le_of_not_lt ((not_congr hle_pred_iff).1 h.not_le) }
 #align pred_order.of_le_pred_iff PredOrder.ofLePredIff
+-/
 
 end LinearOrder
 
@@ -200,31 +212,43 @@ def succ : α → α :=
 #align order.succ Order.succ
 -/
 
+#print Order.le_succ /-
 theorem le_succ : ∀ a : α, a ≤ succ a :=
   SuccOrder.le_succ
 #align order.le_succ Order.le_succ
+-/
 
+#print Order.max_of_succ_le /-
 theorem max_of_succ_le {a : α} : succ a ≤ a → IsMax a :=
   SuccOrder.max_of_succ_le
 #align order.max_of_succ_le Order.max_of_succ_le
+-/
 
+#print Order.succ_le_of_lt /-
 theorem succ_le_of_lt {a b : α} : a < b → succ a ≤ b :=
   SuccOrder.succ_le_of_lt
 #align order.succ_le_of_lt Order.succ_le_of_lt
+-/
 
+#print Order.le_of_lt_succ /-
 theorem le_of_lt_succ {a b : α} : a < succ b → a ≤ b :=
   SuccOrder.le_of_lt_succ
 #align order.le_of_lt_succ Order.le_of_lt_succ
+-/
 
+#print Order.succ_le_iff_isMax /-
 @[simp]
 theorem succ_le_iff_isMax : succ a ≤ a ↔ IsMax a :=
   ⟨max_of_succ_le, fun h => h <| le_succ _⟩
 #align order.succ_le_iff_is_max Order.succ_le_iff_isMax
+-/
 
+#print Order.lt_succ_iff_not_isMax /-
 @[simp]
 theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a :=
   ⟨not_isMax_of_lt, fun ha => (le_succ a).lt_of_not_le fun h => ha <| max_of_succ_le h⟩
 #align order.lt_succ_iff_not_is_max Order.lt_succ_iff_not_isMax
+-/
 
 alias lt_succ_iff_not_is_max ↔ _ lt_succ_of_not_is_max
 #align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMax
@@ -235,26 +259,37 @@ theorem wcovby_succ (a : α) : a ⩿ succ a :=
 #align order.wcovby_succ Order.wcovby_succ
 -/
 
+#print Order.covby_succ_of_not_isMax /-
 theorem covby_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a :=
   (wcovby_succ a).covby_of_lt <| lt_succ_of_not_isMax h
 #align order.covby_succ_of_not_is_max Order.covby_succ_of_not_isMax
+-/
 
+#print Order.lt_succ_iff_of_not_isMax /-
 theorem lt_succ_iff_of_not_isMax (ha : ¬IsMax a) : b < succ a ↔ b ≤ a :=
   ⟨le_of_lt_succ, fun h => h.trans_lt <| lt_succ_of_not_isMax ha⟩
 #align order.lt_succ_iff_of_not_is_max Order.lt_succ_iff_of_not_isMax
+-/
 
+#print Order.succ_le_iff_of_not_isMax /-
 theorem succ_le_iff_of_not_isMax (ha : ¬IsMax a) : succ a ≤ b ↔ a < b :=
   ⟨(lt_succ_of_not_isMax ha).trans_le, succ_le_of_lt⟩
 #align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMax
+-/
 
+#print Order.succ_lt_succ_iff_of_not_isMax /-
 theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a < succ b ↔ a < b :=
   by rw [lt_succ_iff_of_not_is_max hb, succ_le_iff_of_not_is_max ha]
 #align order.succ_lt_succ_iff_of_not_is_max Order.succ_lt_succ_iff_of_not_isMax
+-/
 
+#print Order.succ_le_succ_iff_of_not_isMax /-
 theorem succ_le_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a ≤ succ b ↔ a ≤ b :=
   by rw [succ_le_iff_of_not_is_max ha, lt_succ_iff_of_not_is_max hb]
 #align order.succ_le_succ_iff_of_not_is_max Order.succ_le_succ_iff_of_not_isMax
+-/
 
+#print Order.succ_le_succ /-
 @[simp, mono]
 theorem succ_le_succ (h : a ≤ b) : succ a ≤ succ b :=
   by
@@ -264,18 +299,22 @@ theorem succ_le_succ (h : a ≤ b) : succ a ≤ succ b :=
     · exact succ_le_of_lt ((h.lt_of_not_le hba).trans_le <| le_succ b)
   · rwa [succ_le_iff_of_not_is_max fun ha => hb <| ha.mono h, lt_succ_iff_of_not_is_max hb]
 #align order.succ_le_succ Order.succ_le_succ
+-/
 
 #print Order.succ_mono /-
 theorem succ_mono : Monotone (succ : α → α) := fun a b => succ_le_succ
 #align order.succ_mono Order.succ_mono
 -/
 
+#print Order.le_succ_iterate /-
 theorem le_succ_iterate (k : ℕ) (x : α) : x ≤ (succ^[k]) x :=
   by
   conv_lhs => rw [(by simp only [Function.iterate_id, id.def] : x = (id^[k]) x)]
   exact Monotone.le_iterate_of_le succ_mono le_succ k x
 #align order.le_succ_iterate Order.le_succ_iterate
+-/
 
+#print Order.isMax_iterate_succ_of_eq_of_lt /-
 theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : (succ^[n]) a = (succ^[m]) a)
     (h_lt : n < m) : IsMax ((succ^[n]) a) :=
   by
@@ -285,7 +324,9 @@ theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : (succ^[n]) a = (succ^
   have h_le : n + 1 ≤ m := Nat.succ_le_of_lt h_lt
   exact Monotone.monotone_iterate_of_le_map succ_mono (le_succ a) h_le
 #align order.is_max_iterate_succ_of_eq_of_lt Order.isMax_iterate_succ_of_eq_of_lt
+-/
 
+#print Order.isMax_iterate_succ_of_eq_of_ne /-
 theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : (succ^[n]) a = (succ^[m]) a)
     (h_ne : n ≠ m) : IsMax ((succ^[n]) a) :=
   by
@@ -294,54 +335,77 @@ theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : (succ^[n]) a = (succ^
   · rw [h_eq]
     exact is_max_iterate_succ_of_eq_of_lt h_eq.symm (lt_of_le_of_ne h h_ne.symm)
 #align order.is_max_iterate_succ_of_eq_of_ne Order.isMax_iterate_succ_of_eq_of_ne
+-/
 
+#print Order.Iio_succ_of_not_isMax /-
 theorem Iio_succ_of_not_isMax (ha : ¬IsMax a) : Iio (succ a) = Iic a :=
   Set.ext fun x => lt_succ_iff_of_not_isMax ha
 #align order.Iio_succ_of_not_is_max Order.Iio_succ_of_not_isMax
+-/
 
+#print Order.Ici_succ_of_not_isMax /-
 theorem Ici_succ_of_not_isMax (ha : ¬IsMax a) : Ici (succ a) = Ioi a :=
   Set.ext fun x => succ_le_iff_of_not_isMax ha
 #align order.Ici_succ_of_not_is_max Order.Ici_succ_of_not_isMax
+-/
 
+#print Order.Ico_succ_right_of_not_isMax /-
 theorem Ico_succ_right_of_not_isMax (hb : ¬IsMax b) : Ico a (succ b) = Icc a b := by
   rw [← Ici_inter_Iio, Iio_succ_of_not_is_max hb, Ici_inter_Iic]
 #align order.Ico_succ_right_of_not_is_max Order.Ico_succ_right_of_not_isMax
+-/
 
+#print Order.Ioo_succ_right_of_not_isMax /-
 theorem Ioo_succ_right_of_not_isMax (hb : ¬IsMax b) : Ioo a (succ b) = Ioc a b := by
   rw [← Ioi_inter_Iio, Iio_succ_of_not_is_max hb, Ioi_inter_Iic]
 #align order.Ioo_succ_right_of_not_is_max Order.Ioo_succ_right_of_not_isMax
+-/
 
+#print Order.Icc_succ_left_of_not_isMax /-
 theorem Icc_succ_left_of_not_isMax (ha : ¬IsMax a) : Icc (succ a) b = Ioc a b := by
   rw [← Ici_inter_Iic, Ici_succ_of_not_is_max ha, Ioi_inter_Iic]
 #align order.Icc_succ_left_of_not_is_max Order.Icc_succ_left_of_not_isMax
+-/
 
+#print Order.Ico_succ_left_of_not_isMax /-
 theorem Ico_succ_left_of_not_isMax (ha : ¬IsMax a) : Ico (succ a) b = Ioo a b := by
   rw [← Ici_inter_Iio, Ici_succ_of_not_is_max ha, Ioi_inter_Iio]
 #align order.Ico_succ_left_of_not_is_max Order.Ico_succ_left_of_not_isMax
+-/
 
 section NoMaxOrder
 
 variable [NoMaxOrder α]
 
+#print Order.lt_succ /-
 theorem lt_succ (a : α) : a < succ a :=
   lt_succ_of_not_isMax <| not_isMax a
 #align order.lt_succ Order.lt_succ
+-/
 
+#print Order.lt_succ_iff /-
 @[simp]
 theorem lt_succ_iff : a < succ b ↔ a ≤ b :=
   lt_succ_iff_of_not_isMax <| not_isMax b
 #align order.lt_succ_iff Order.lt_succ_iff
+-/
 
+#print Order.succ_le_iff /-
 @[simp]
 theorem succ_le_iff : succ a ≤ b ↔ a < b :=
   succ_le_iff_of_not_isMax <| not_isMax a
 #align order.succ_le_iff Order.succ_le_iff
+-/
 
+#print Order.succ_le_succ_iff /-
 theorem succ_le_succ_iff : succ a ≤ succ b ↔ a ≤ b := by simp
 #align order.succ_le_succ_iff Order.succ_le_succ_iff
+-/
 
+#print Order.succ_lt_succ_iff /-
 theorem succ_lt_succ_iff : succ a < succ b ↔ a < b := by simp
 #align order.succ_lt_succ_iff Order.succ_lt_succ_iff
+-/
 
 alias succ_le_succ_iff ↔ le_of_succ_le_succ _
 #align order.le_of_succ_le_succ Order.le_of_succ_le_succ
@@ -350,42 +414,58 @@ alias succ_lt_succ_iff ↔ lt_of_succ_lt_succ succ_lt_succ
 #align order.lt_of_succ_lt_succ Order.lt_of_succ_lt_succ
 #align order.succ_lt_succ Order.succ_lt_succ
 
+#print Order.succ_strictMono /-
 theorem succ_strictMono : StrictMono (succ : α → α) := fun a b => succ_lt_succ
 #align order.succ_strict_mono Order.succ_strictMono
+-/
 
+#print Order.covby_succ /-
 theorem covby_succ (a : α) : a ⋖ succ a :=
   covby_succ_of_not_isMax <| not_isMax a
 #align order.covby_succ Order.covby_succ
+-/
 
+#print Order.Iio_succ /-
 @[simp]
 theorem Iio_succ (a : α) : Iio (succ a) = Iic a :=
   Iio_succ_of_not_isMax <| not_isMax _
 #align order.Iio_succ Order.Iio_succ
+-/
 
+#print Order.Ici_succ /-
 @[simp]
 theorem Ici_succ (a : α) : Ici (succ a) = Ioi a :=
   Ici_succ_of_not_isMax <| not_isMax _
 #align order.Ici_succ Order.Ici_succ
+-/
 
+#print Order.Ico_succ_right /-
 @[simp]
 theorem Ico_succ_right (a b : α) : Ico a (succ b) = Icc a b :=
   Ico_succ_right_of_not_isMax <| not_isMax _
 #align order.Ico_succ_right Order.Ico_succ_right
+-/
 
+#print Order.Ioo_succ_right /-
 @[simp]
 theorem Ioo_succ_right (a b : α) : Ioo a (succ b) = Ioc a b :=
   Ioo_succ_right_of_not_isMax <| not_isMax _
 #align order.Ioo_succ_right Order.Ioo_succ_right
+-/
 
+#print Order.Icc_succ_left /-
 @[simp]
 theorem Icc_succ_left (a b : α) : Icc (succ a) b = Ioc a b :=
   Icc_succ_left_of_not_isMax <| not_isMax _
 #align order.Icc_succ_left Order.Icc_succ_left
+-/
 
+#print Order.Ico_succ_left /-
 @[simp]
 theorem Ico_succ_left (a b : α) : Ico (succ a) b = Ioo a b :=
   Ico_succ_left_of_not_isMax <| not_isMax _
 #align order.Ico_succ_left Order.Ico_succ_left
+-/
 
 end NoMaxOrder
 
@@ -395,20 +475,25 @@ section PartialOrder
 
 variable [PartialOrder α] [SuccOrder α] {a b : α}
 
+#print Order.succ_eq_iff_isMax /-
 @[simp]
 theorem succ_eq_iff_isMax : succ a = a ↔ IsMax a :=
   ⟨fun h => max_of_succ_le h.le, fun h => h.eq_of_ge <| le_succ _⟩
 #align order.succ_eq_iff_is_max Order.succ_eq_iff_isMax
+-/
 
 alias succ_eq_iff_is_max ↔ _ _root_.is_max.succ_eq
 #align is_max.succ_eq IsMax.succ_eq
 
+#print Order.succ_eq_succ_iff_of_not_isMax /-
 theorem succ_eq_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a = succ b ↔ a = b :=
   by
   rw [eq_iff_le_not_lt, eq_iff_le_not_lt, succ_le_succ_iff_of_not_is_max ha hb,
     succ_lt_succ_iff_of_not_is_max ha hb]
 #align order.succ_eq_succ_iff_of_not_is_max Order.succ_eq_succ_iff_of_not_isMax
+-/
 
+#print Order.le_le_succ_iff /-
 theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
   by
   refine'
@@ -420,28 +505,37 @@ theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
   · exact ⟨le_rfl, le_succ b⟩
   · exact ⟨le_succ a, le_rfl⟩
 #align order.le_le_succ_iff Order.le_le_succ_iff
+-/
 
+#print Covby.succ_eq /-
 theorem Covby.succ_eq (h : a ⋖ b) : succ a = b :=
   (succ_le_of_lt h.lt).eq_of_not_lt fun h' => h.2 (lt_succ_of_not_isMax h.lt.not_isMax) h'
 #align covby.succ_eq Covby.succ_eq
+-/
 
+#print Wcovby.le_succ /-
 theorem Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.succ_eq.ge
   · exact le_succ _
 #align wcovby.le_succ Wcovby.le_succ
+-/
 
+#print Order.le_succ_iff_eq_or_le /-
 theorem le_succ_iff_eq_or_le : a ≤ succ b ↔ a = succ b ∨ a ≤ b :=
   by
   by_cases hb : IsMax b
   · rw [hb.succ_eq, or_iff_right_of_imp le_of_eq]
   · rw [← lt_succ_iff_of_not_is_max hb, le_iff_eq_or_lt]
 #align order.le_succ_iff_eq_or_le Order.le_succ_iff_eq_or_le
+-/
 
+#print Order.lt_succ_iff_eq_or_lt_of_not_isMax /-
 theorem lt_succ_iff_eq_or_lt_of_not_isMax (hb : ¬IsMax b) : a < succ b ↔ a = b ∨ a < b :=
   (lt_succ_iff_of_not_isMax hb).trans le_iff_eq_or_lt
 #align order.lt_succ_iff_eq_or_lt_of_not_is_max Order.lt_succ_iff_eq_or_lt_of_not_isMax
+-/
 
 #print Order.Iic_succ /-
 theorem Iic_succ (a : α) : Iic (succ a) = insert (succ a) (Iic a) :=
@@ -449,66 +543,92 @@ theorem Iic_succ (a : α) : Iic (succ a) = insert (succ a) (Iic a) :=
 #align order.Iic_succ Order.Iic_succ
 -/
 
+#print Order.Icc_succ_right /-
 theorem Icc_succ_right (h : a ≤ succ b) : Icc a (succ b) = insert (succ b) (Icc a b) := by
   simp_rw [← Ici_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ici.2 h)]
 #align order.Icc_succ_right Order.Icc_succ_right
+-/
 
+#print Order.Ioc_succ_right /-
 theorem Ioc_succ_right (h : a < succ b) : Ioc a (succ b) = insert (succ b) (Ioc a b) := by
   simp_rw [← Ioi_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ioi.2 h)]
 #align order.Ioc_succ_right Order.Ioc_succ_right
+-/
 
+#print Order.Iio_succ_eq_insert_of_not_isMax /-
 theorem Iio_succ_eq_insert_of_not_isMax (h : ¬IsMax a) : Iio (succ a) = insert a (Iio a) :=
   ext fun _ => lt_succ_iff_eq_or_lt_of_not_isMax h
 #align order.Iio_succ_eq_insert_of_not_is_max Order.Iio_succ_eq_insert_of_not_isMax
+-/
 
+#print Order.Ico_succ_right_eq_insert_of_not_isMax /-
 theorem Ico_succ_right_eq_insert_of_not_isMax (h₁ : a ≤ b) (h₂ : ¬IsMax b) :
     Ico a (succ b) = insert b (Ico a b) := by
   simp_rw [← Iio_inter_Ici, Iio_succ_eq_insert_of_not_is_max h₂, insert_inter_of_mem (mem_Ici.2 h₁)]
 #align order.Ico_succ_right_eq_insert_of_not_is_max Order.Ico_succ_right_eq_insert_of_not_isMax
+-/
 
+#print Order.Ioo_succ_right_eq_insert_of_not_isMax /-
 theorem Ioo_succ_right_eq_insert_of_not_isMax (h₁ : a < b) (h₂ : ¬IsMax b) :
     Ioo a (succ b) = insert b (Ioo a b) := by
   simp_rw [← Iio_inter_Ioi, Iio_succ_eq_insert_of_not_is_max h₂, insert_inter_of_mem (mem_Ioi.2 h₁)]
 #align order.Ioo_succ_right_eq_insert_of_not_is_max Order.Ioo_succ_right_eq_insert_of_not_isMax
+-/
 
 section NoMaxOrder
 
 variable [NoMaxOrder α]
 
+#print Order.succ_eq_succ_iff /-
 @[simp]
 theorem succ_eq_succ_iff : succ a = succ b ↔ a = b :=
   succ_eq_succ_iff_of_not_isMax (not_isMax a) (not_isMax b)
 #align order.succ_eq_succ_iff Order.succ_eq_succ_iff
+-/
 
+#print Order.succ_injective /-
 theorem succ_injective : Injective (succ : α → α) := fun a b => succ_eq_succ_iff.1
 #align order.succ_injective Order.succ_injective
+-/
 
+#print Order.succ_ne_succ_iff /-
 theorem succ_ne_succ_iff : succ a ≠ succ b ↔ a ≠ b :=
   succ_injective.ne_iff
 #align order.succ_ne_succ_iff Order.succ_ne_succ_iff
+-/
 
 alias succ_ne_succ_iff ↔ _ succ_ne_succ
 #align order.succ_ne_succ Order.succ_ne_succ
 
+#print Order.lt_succ_iff_eq_or_lt /-
 theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b :=
   lt_succ_iff.trans le_iff_eq_or_lt
 #align order.lt_succ_iff_eq_or_lt Order.lt_succ_iff_eq_or_lt
+-/
 
+#print Order.succ_eq_iff_covby /-
 theorem succ_eq_iff_covby : succ a = b ↔ a ⋖ b :=
   ⟨by rintro rfl; exact covby_succ _, Covby.succ_eq⟩
 #align order.succ_eq_iff_covby Order.succ_eq_iff_covby
+-/
 
+#print Order.Iio_succ_eq_insert /-
 theorem Iio_succ_eq_insert (a : α) : Iio (succ a) = insert a (Iio a) :=
   Iio_succ_eq_insert_of_not_isMax <| not_isMax a
 #align order.Iio_succ_eq_insert Order.Iio_succ_eq_insert
+-/
 
+#print Order.Ico_succ_right_eq_insert /-
 theorem Ico_succ_right_eq_insert (h : a ≤ b) : Ico a (succ b) = insert b (Ico a b) :=
   Ico_succ_right_eq_insert_of_not_isMax h <| not_isMax b
 #align order.Ico_succ_right_eq_insert Order.Ico_succ_right_eq_insert
+-/
 
+#print Order.Ioo_succ_right_eq_insert /-
 theorem Ioo_succ_right_eq_insert (h : a < b) : Ioo a (succ b) = insert b (Ioo a b) :=
   Ioo_succ_right_eq_insert_of_not_isMax h <| not_isMax b
 #align order.Ioo_succ_right_eq_insert Order.Ioo_succ_right_eq_insert
+-/
 
 end NoMaxOrder
 
@@ -598,31 +718,43 @@ def pred : α → α :=
 #align order.pred Order.pred
 -/
 
+#print Order.pred_le /-
 theorem pred_le : ∀ a : α, pred a ≤ a :=
   PredOrder.pred_le
 #align order.pred_le Order.pred_le
+-/
 
+#print Order.min_of_le_pred /-
 theorem min_of_le_pred {a : α} : a ≤ pred a → IsMin a :=
   PredOrder.min_of_le_pred
 #align order.min_of_le_pred Order.min_of_le_pred
+-/
 
+#print Order.le_pred_of_lt /-
 theorem le_pred_of_lt {a b : α} : a < b → a ≤ pred b :=
   PredOrder.le_pred_of_lt
 #align order.le_pred_of_lt Order.le_pred_of_lt
+-/
 
+#print Order.le_of_pred_lt /-
 theorem le_of_pred_lt {a b : α} : pred a < b → a ≤ b :=
   PredOrder.le_of_pred_lt
 #align order.le_of_pred_lt Order.le_of_pred_lt
+-/
 
+#print Order.le_pred_iff_isMin /-
 @[simp]
 theorem le_pred_iff_isMin : a ≤ pred a ↔ IsMin a :=
   ⟨min_of_le_pred, fun h => h <| pred_le _⟩
 #align order.le_pred_iff_is_min Order.le_pred_iff_isMin
+-/
 
+#print Order.pred_lt_iff_not_isMin /-
 @[simp]
 theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a :=
   ⟨not_isMin_of_lt, fun ha => (pred_le a).lt_of_not_le fun h => ha <| min_of_le_pred h⟩
 #align order.pred_lt_iff_not_is_min Order.pred_lt_iff_not_isMin
+-/
 
 alias pred_lt_iff_not_is_min ↔ _ pred_lt_of_not_is_min
 #align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMin
@@ -633,91 +765,127 @@ theorem pred_wcovby (a : α) : pred a ⩿ a :=
 #align order.pred_wcovby Order.pred_wcovby
 -/
 
+#print Order.pred_covby_of_not_isMin /-
 theorem pred_covby_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a :=
   (pred_wcovby a).covby_of_lt <| pred_lt_of_not_isMin h
 #align order.pred_covby_of_not_is_min Order.pred_covby_of_not_isMin
+-/
 
+#print Order.pred_lt_iff_of_not_isMin /-
 theorem pred_lt_iff_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a ≤ b :=
   ⟨le_of_pred_lt, (pred_lt_of_not_isMin ha).trans_le⟩
 #align order.pred_lt_iff_of_not_is_min Order.pred_lt_iff_of_not_isMin
+-/
 
+#print Order.le_pred_iff_of_not_isMin /-
 theorem le_pred_iff_of_not_isMin (ha : ¬IsMin a) : b ≤ pred a ↔ b < a :=
   ⟨fun h => h.trans_lt <| pred_lt_of_not_isMin ha, le_pred_of_lt⟩
 #align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMin
+-/
 
+#print Order.pred_le_pred /-
 @[simp, mono]
 theorem pred_le_pred {a b : α} (h : a ≤ b) : pred a ≤ pred b :=
   succ_le_succ h.dual
 #align order.pred_le_pred Order.pred_le_pred
+-/
 
 #print Order.pred_mono /-
 theorem pred_mono : Monotone (pred : α → α) := fun a b => pred_le_pred
 #align order.pred_mono Order.pred_mono
 -/
 
+#print Order.pred_iterate_le /-
 theorem pred_iterate_le (k : ℕ) (x : α) : (pred^[k]) x ≤ x :=
   by
   conv_rhs => rw [(by simp only [Function.iterate_id, id.def] : x = (id^[k]) x)]
   exact Monotone.iterate_le_of_le pred_mono pred_le k x
 #align order.pred_iterate_le Order.pred_iterate_le
+-/
 
+#print Order.isMin_iterate_pred_of_eq_of_lt /-
 theorem isMin_iterate_pred_of_eq_of_lt {n m : ℕ} (h_eq : (pred^[n]) a = (pred^[m]) a)
     (h_lt : n < m) : IsMin ((pred^[n]) a) :=
   @isMax_iterate_succ_of_eq_of_lt αᵒᵈ _ _ _ _ _ h_eq h_lt
 #align order.is_min_iterate_pred_of_eq_of_lt Order.isMin_iterate_pred_of_eq_of_lt
+-/
 
+#print Order.isMin_iterate_pred_of_eq_of_ne /-
 theorem isMin_iterate_pred_of_eq_of_ne {n m : ℕ} (h_eq : (pred^[n]) a = (pred^[m]) a)
     (h_ne : n ≠ m) : IsMin ((pred^[n]) a) :=
   @isMax_iterate_succ_of_eq_of_ne αᵒᵈ _ _ _ _ _ h_eq h_ne
 #align order.is_min_iterate_pred_of_eq_of_ne Order.isMin_iterate_pred_of_eq_of_ne
+-/
 
+#print Order.Ioi_pred_of_not_isMin /-
 theorem Ioi_pred_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = Ici a :=
   Set.ext fun x => pred_lt_iff_of_not_isMin ha
 #align order.Ioi_pred_of_not_is_min Order.Ioi_pred_of_not_isMin
+-/
 
+#print Order.Iic_pred_of_not_isMin /-
 theorem Iic_pred_of_not_isMin (ha : ¬IsMin a) : Iic (pred a) = Iio a :=
   Set.ext fun x => le_pred_iff_of_not_isMin ha
 #align order.Iic_pred_of_not_is_min Order.Iic_pred_of_not_isMin
+-/
 
+#print Order.Ioc_pred_left_of_not_isMin /-
 theorem Ioc_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioc (pred a) b = Icc a b := by
   rw [← Ioi_inter_Iic, Ioi_pred_of_not_is_min ha, Ici_inter_Iic]
 #align order.Ioc_pred_left_of_not_is_min Order.Ioc_pred_left_of_not_isMin
+-/
 
+#print Order.Ioo_pred_left_of_not_isMin /-
 theorem Ioo_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioo (pred a) b = Ico a b := by
   rw [← Ioi_inter_Iio, Ioi_pred_of_not_is_min ha, Ici_inter_Iio]
 #align order.Ioo_pred_left_of_not_is_min Order.Ioo_pred_left_of_not_isMin
+-/
 
+#print Order.Icc_pred_right_of_not_isMin /-
 theorem Icc_pred_right_of_not_isMin (ha : ¬IsMin b) : Icc a (pred b) = Ico a b := by
   rw [← Ici_inter_Iic, Iic_pred_of_not_is_min ha, Ici_inter_Iio]
 #align order.Icc_pred_right_of_not_is_min Order.Icc_pred_right_of_not_isMin
+-/
 
+#print Order.Ioc_pred_right_of_not_isMin /-
 theorem Ioc_pred_right_of_not_isMin (ha : ¬IsMin b) : Ioc a (pred b) = Ioo a b := by
   rw [← Ioi_inter_Iic, Iic_pred_of_not_is_min ha, Ioi_inter_Iio]
 #align order.Ioc_pred_right_of_not_is_min Order.Ioc_pred_right_of_not_isMin
+-/
 
 section NoMinOrder
 
 variable [NoMinOrder α]
 
+#print Order.pred_lt /-
 theorem pred_lt (a : α) : pred a < a :=
   pred_lt_of_not_isMin <| not_isMin a
 #align order.pred_lt Order.pred_lt
+-/
 
+#print Order.pred_lt_iff /-
 @[simp]
 theorem pred_lt_iff : pred a < b ↔ a ≤ b :=
   pred_lt_iff_of_not_isMin <| not_isMin a
 #align order.pred_lt_iff Order.pred_lt_iff
+-/
 
+#print Order.le_pred_iff /-
 @[simp]
 theorem le_pred_iff : a ≤ pred b ↔ a < b :=
   le_pred_iff_of_not_isMin <| not_isMin b
 #align order.le_pred_iff Order.le_pred_iff
+-/
 
+#print Order.pred_le_pred_iff /-
 theorem pred_le_pred_iff : pred a ≤ pred b ↔ a ≤ b := by simp
 #align order.pred_le_pred_iff Order.pred_le_pred_iff
+-/
 
+#print Order.pred_lt_pred_iff /-
 theorem pred_lt_pred_iff : pred a < pred b ↔ a < b := by simp
 #align order.pred_lt_pred_iff Order.pred_lt_pred_iff
+-/
 
 alias pred_le_pred_iff ↔ le_of_pred_le_pred _
 #align order.le_of_pred_le_pred Order.le_of_pred_le_pred
@@ -726,42 +894,58 @@ alias pred_lt_pred_iff ↔ lt_of_pred_lt_pred pred_lt_pred
 #align order.lt_of_pred_lt_pred Order.lt_of_pred_lt_pred
 #align order.pred_lt_pred Order.pred_lt_pred
 
+#print Order.pred_strictMono /-
 theorem pred_strictMono : StrictMono (pred : α → α) := fun a b => pred_lt_pred
 #align order.pred_strict_mono Order.pred_strictMono
+-/
 
+#print Order.pred_covby /-
 theorem pred_covby (a : α) : pred a ⋖ a :=
   pred_covby_of_not_isMin <| not_isMin a
 #align order.pred_covby Order.pred_covby
+-/
 
+#print Order.Ioi_pred /-
 @[simp]
 theorem Ioi_pred (a : α) : Ioi (pred a) = Ici a :=
   Ioi_pred_of_not_isMin <| not_isMin a
 #align order.Ioi_pred Order.Ioi_pred
+-/
 
+#print Order.Iic_pred /-
 @[simp]
 theorem Iic_pred (a : α) : Iic (pred a) = Iio a :=
   Iic_pred_of_not_isMin <| not_isMin a
 #align order.Iic_pred Order.Iic_pred
+-/
 
+#print Order.Ioc_pred_left /-
 @[simp]
 theorem Ioc_pred_left (a b : α) : Ioc (pred a) b = Icc a b :=
   Ioc_pred_left_of_not_isMin <| not_isMin _
 #align order.Ioc_pred_left Order.Ioc_pred_left
+-/
 
+#print Order.Ioo_pred_left /-
 @[simp]
 theorem Ioo_pred_left (a b : α) : Ioo (pred a) b = Ico a b :=
   Ioo_pred_left_of_not_isMin <| not_isMin _
 #align order.Ioo_pred_left Order.Ioo_pred_left
+-/
 
+#print Order.Icc_pred_right /-
 @[simp]
 theorem Icc_pred_right (a b : α) : Icc a (pred b) = Ico a b :=
   Icc_pred_right_of_not_isMin <| not_isMin _
 #align order.Icc_pred_right Order.Icc_pred_right
+-/
 
+#print Order.Ioc_pred_right /-
 @[simp]
 theorem Ioc_pred_right (a b : α) : Ioc a (pred b) = Ioo a b :=
   Ioc_pred_right_of_not_isMin <| not_isMin _
 #align order.Ioc_pred_right Order.Ioc_pred_right
+-/
 
 end NoMinOrder
 
@@ -771,14 +955,17 @@ section PartialOrder
 
 variable [PartialOrder α] [PredOrder α] {a b : α}
 
+#print Order.pred_eq_iff_isMin /-
 @[simp]
 theorem pred_eq_iff_isMin : pred a = a ↔ IsMin a :=
   ⟨fun h => min_of_le_pred h.ge, fun h => h.eq_of_le <| pred_le _⟩
 #align order.pred_eq_iff_is_min Order.pred_eq_iff_isMin
+-/
 
 alias pred_eq_iff_is_min ↔ _ _root_.is_min.pred_eq
 #align is_min.pred_eq IsMin.pred_eq
 
+#print Order.pred_le_le_iff /-
 theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a :=
   by
   refine'
@@ -788,28 +975,37 @@ theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = p
   · exact ⟨pred_le b, le_rfl⟩
   · exact ⟨le_rfl, pred_le a⟩
 #align order.pred_le_le_iff Order.pred_le_le_iff
+-/
 
+#print Covby.pred_eq /-
 theorem Covby.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
   (le_pred_of_lt h.lt).eq_of_not_gt fun h' => h.2 h' <| pred_lt_of_not_isMin h.lt.not_isMin
 #align covby.pred_eq Covby.pred_eq
+-/
 
+#print Wcovby.pred_le /-
 theorem Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.pred_eq.le
   · exact pred_le _
 #align wcovby.pred_le Wcovby.pred_le
+-/
 
+#print Order.pred_le_iff_eq_or_le /-
 theorem pred_le_iff_eq_or_le : pred a ≤ b ↔ b = pred a ∨ a ≤ b :=
   by
   by_cases ha : IsMin a
   · rw [ha.pred_eq, or_iff_right_of_imp ge_of_eq]
   · rw [← pred_lt_iff_of_not_is_min ha, le_iff_eq_or_lt, eq_comm]
 #align order.pred_le_iff_eq_or_le Order.pred_le_iff_eq_or_le
+-/
 
+#print Order.pred_lt_iff_eq_or_lt_of_not_isMin /-
 theorem pred_lt_iff_eq_or_lt_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a = b ∨ a < b :=
   (pred_lt_iff_of_not_isMin ha).trans le_iff_eq_or_lt
 #align order.pred_lt_iff_eq_or_lt_of_not_is_min Order.pred_lt_iff_eq_or_lt_of_not_isMin
+-/
 
 #print Order.Ici_pred /-
 theorem Ici_pred (a : α) : Ici (pred a) = insert (pred a) (Ici a) :=
@@ -817,58 +1013,80 @@ theorem Ici_pred (a : α) : Ici (pred a) = insert (pred a) (Ici a) :=
 #align order.Ici_pred Order.Ici_pred
 -/
 
+#print Order.Ioi_pred_eq_insert_of_not_isMin /-
 theorem Ioi_pred_eq_insert_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = insert a (Ioi a) :=
   by
   ext x; simp only [insert, mem_set_of, @eq_comm _ x a]
   exact pred_lt_iff_eq_or_lt_of_not_is_min ha
 #align order.Ioi_pred_eq_insert_of_not_is_min Order.Ioi_pred_eq_insert_of_not_isMin
+-/
 
+#print Order.Icc_pred_left /-
 theorem Icc_pred_left (h : pred a ≤ b) : Icc (pred a) b = insert (pred a) (Icc a b) := by
   simp_rw [← Ici_inter_Iic, Ici_pred, insert_inter_of_mem (mem_Iic.2 h)]
 #align order.Icc_pred_left Order.Icc_pred_left
+-/
 
+#print Order.Ico_pred_left /-
 theorem Ico_pred_left (h : pred a < b) : Ico (pred a) b = insert (pred a) (Ico a b) := by
   simp_rw [← Ici_inter_Iio, Ici_pred, insert_inter_of_mem (mem_Iio.2 h)]
 #align order.Ico_pred_left Order.Ico_pred_left
+-/
 
 section NoMinOrder
 
 variable [NoMinOrder α]
 
+#print Order.pred_eq_pred_iff /-
 @[simp]
 theorem pred_eq_pred_iff : pred a = pred b ↔ a = b := by
   simp_rw [eq_iff_le_not_lt, pred_le_pred_iff, pred_lt_pred_iff]
 #align order.pred_eq_pred_iff Order.pred_eq_pred_iff
+-/
 
+#print Order.pred_injective /-
 theorem pred_injective : Injective (pred : α → α) := fun a b => pred_eq_pred_iff.1
 #align order.pred_injective Order.pred_injective
+-/
 
+#print Order.pred_ne_pred_iff /-
 theorem pred_ne_pred_iff : pred a ≠ pred b ↔ a ≠ b :=
   pred_injective.ne_iff
 #align order.pred_ne_pred_iff Order.pred_ne_pred_iff
+-/
 
 alias pred_ne_pred_iff ↔ _ pred_ne_pred
 #align order.pred_ne_pred Order.pred_ne_pred
 
+#print Order.pred_lt_iff_eq_or_lt /-
 theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b :=
   pred_lt_iff.trans le_iff_eq_or_lt
 #align order.pred_lt_iff_eq_or_lt Order.pred_lt_iff_eq_or_lt
+-/
 
+#print Order.pred_eq_iff_covby /-
 theorem pred_eq_iff_covby : pred b = a ↔ a ⋖ b :=
   ⟨by rintro rfl; exact pred_covby _, Covby.pred_eq⟩
 #align order.pred_eq_iff_covby Order.pred_eq_iff_covby
+-/
 
+#print Order.Ioi_pred_eq_insert /-
 theorem Ioi_pred_eq_insert (a : α) : Ioi (pred a) = insert a (Ioi a) :=
   ext fun _ => pred_lt_iff_eq_or_lt.trans <| or_congr_left eq_comm
 #align order.Ioi_pred_eq_insert Order.Ioi_pred_eq_insert
+-/
 
+#print Order.Ico_pred_right_eq_insert /-
 theorem Ico_pred_right_eq_insert (h : a ≤ b) : Ioc (pred a) b = insert a (Ioc a b) := by
   simp_rw [← Ioi_inter_Iic, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iic.2 h)]
 #align order.Ico_pred_right_eq_insert Order.Ico_pred_right_eq_insert
+-/
 
+#print Order.Ioo_pred_right_eq_insert /-
 theorem Ioo_pred_right_eq_insert (h : a < b) : Ioo (pred a) b = insert a (Ioo a b) := by
   simp_rw [← Ioi_inter_Iio, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iio.2 h)]
 #align order.Ioo_pred_right_eq_insert Order.Ioo_pred_right_eq_insert
+-/
 
 end NoMinOrder
 
@@ -951,26 +1169,35 @@ section SuccPredOrder
 
 variable [PartialOrder α] [SuccOrder α] [PredOrder α] {a b : α}
 
+#print Order.succ_pred_of_not_isMin /-
 @[simp]
 theorem succ_pred_of_not_isMin (h : ¬IsMin a) : succ (pred a) = a :=
   (pred_covby_of_not_isMin h).succ_eq
 #align order.succ_pred_of_not_is_min Order.succ_pred_of_not_isMin
+-/
 
+#print Order.pred_succ_of_not_isMax /-
 @[simp]
 theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a :=
   (covby_succ_of_not_isMax h).pred_eq
 #align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMax
+-/
 
+#print Order.succ_pred /-
 @[simp]
 theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a :=
   (pred_covby _).succ_eq
 #align order.succ_pred Order.succ_pred
+-/
 
+#print Order.pred_succ /-
 @[simp]
 theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
   (covby_succ _).pred_eq
 #align order.pred_succ Order.pred_succ
+-/
 
+#print Order.pred_succ_iterate_of_not_isMax /-
 theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^[n - 1]) i)) :
     (pred^[n]) ((succ^[n]) i) = i := by
   induction' n with n hn
@@ -993,11 +1220,14 @@ theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^
   rw [pred_succ_of_not_is_max hin]
   exact hn h_not_max
 #align order.pred_succ_iterate_of_not_is_max Order.pred_succ_iterate_of_not_isMax
+-/
 
+#print Order.succ_pred_iterate_of_not_isMin /-
 theorem succ_pred_iterate_of_not_isMin (i : α) (n : ℕ) (hin : ¬IsMin ((pred^[n - 1]) i)) :
     (succ^[n]) ((pred^[n]) i) = i :=
   @pred_succ_iterate_of_not_isMax αᵒᵈ _ _ _ i n hin
 #align order.succ_pred_iterate_of_not_is_min Order.succ_pred_iterate_of_not_isMin
+-/
 
 end SuccPredOrder
 
@@ -1119,10 +1349,12 @@ theorem pred_top : pred (⊤ : WithTop α) = ↑(⊤ : α) :=
   rfl
 #align with_top.pred_top WithTop.pred_top
 
+#print WithTop.pred_coe /-
 @[simp]
 theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
   rfl
 #align with_top.pred_coe WithTop.pred_coe
+-/
 
 @[simp]
 theorem pred_untop :
@@ -1141,6 +1373,7 @@ section Succ
 
 variable [Preorder α] [NoMaxOrder α] [SuccOrder α]
 
+#print WithTop.succOrderOfNoMaxOrder /-
 instance succOrderOfNoMaxOrder : SuccOrder (WithTop α)
     where
   succ a :=
@@ -1168,11 +1401,14 @@ instance succOrderOfNoMaxOrder : SuccOrder (WithTop α)
     · exact le_top
     · exact some_le_some.2 (le_of_lt_succ <| some_lt_some.1 h)
 #align with_top.succ_order_of_no_max_order WithTop.succOrderOfNoMaxOrder
+-/
 
+#print WithTop.succ_coe /-
 @[simp]
 theorem succ_coe (a : α) : succ (↑a : WithTop α) = ↑(succ a) :=
   rfl
 #align with_top.succ_coe WithTop.succ_coe
+-/
 
 end Succ
 
@@ -1234,10 +1470,12 @@ theorem succ_bot : succ (⊥ : WithBot α) = ↑(⊥ : α) :=
   rfl
 #align with_bot.succ_bot WithBot.succ_bot
 
+#print WithBot.succ_coe /-
 @[simp]
 theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
   rfl
 #align with_bot.succ_coe WithBot.succ_coe
+-/
 
 @[simp]
 theorem succ_unbot :
@@ -1330,6 +1568,7 @@ section Pred
 
 variable [Preorder α] [NoMinOrder α] [PredOrder α]
 
+#print WithBot.predOrderOfNoMinOrder /-
 instance predOrderOfNoMinOrder : PredOrder (WithBot α)
     where
   pred a :=
@@ -1357,11 +1596,14 @@ instance predOrderOfNoMinOrder : PredOrder (WithBot α)
     · exact bot_le
     · exact some_le_some.2 (le_of_pred_lt <| some_lt_some.1 h)
 #align with_bot.pred_order_of_no_min_order WithBot.predOrderOfNoMinOrder
+-/
 
+#print WithBot.pred_coe /-
 @[simp]
 theorem pred_coe (a : α) : pred (↑a : WithBot α) = ↑(pred a) :=
   rfl
 #align with_bot.pred_coe WithBot.pred_coe
+-/
 
 end Pred
 
@@ -1401,17 +1643,22 @@ variable [SuccOrder α] [IsSuccArchimedean α] {a b : α}
 instance : IsPredArchimedean αᵒᵈ :=
   ⟨fun a b h => by convert exists_succ_iterate_of_le h.of_dual⟩
 
+#print LE.le.exists_succ_iterate /-
 theorem LE.le.exists_succ_iterate (h : a ≤ b) : ∃ n, (succ^[n]) a = b :=
   exists_succ_iterate_of_le h
 #align has_le.le.exists_succ_iterate LE.le.exists_succ_iterate
+-/
 
+#print exists_succ_iterate_iff_le /-
 theorem exists_succ_iterate_iff_le : (∃ n, (succ^[n]) a = b) ↔ a ≤ b :=
   by
   refine' ⟨_, exists_succ_iterate_of_le⟩
   rintro ⟨n, rfl⟩
   exact id_le_iterate_of_id_le le_succ n a
 #align exists_succ_iterate_iff_le exists_succ_iterate_iff_le
+-/
 
+#print Succ.rec /-
 /-- Induction principle on a type with a `succ_order` for all elements above a given element `m`. -/
 @[elab_as_elim]
 theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n → P n → P (succ n)) ⦃n : α⦄
@@ -1421,12 +1668,15 @@ theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n →
   · exact h0
   · rw [Function.iterate_succ_apply']; exact h1 _ (id_le_iterate_of_id_le le_succ n m) ih
 #align succ.rec Succ.rec
+-/
 
+#print Succ.rec_iff /-
 theorem Succ.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (succ a)) {a b : α} (h : a ≤ b) :
     p a ↔ p b := by
   obtain ⟨n, rfl⟩ := h.exists_succ_iterate
   exact iterate.rec (fun b => p a ↔ p b) (fun c hc => hc.trans (hsucc _)) Iff.rfl n
 #align succ.rec_iff Succ.rec_iff
+-/
 
 end SuccOrder
 
@@ -1437,25 +1687,33 @@ variable [PredOrder α] [IsPredArchimedean α] {a b : α}
 instance : IsSuccArchimedean αᵒᵈ :=
   ⟨fun a b h => by convert exists_pred_iterate_of_le h.of_dual⟩
 
+#print LE.le.exists_pred_iterate /-
 theorem LE.le.exists_pred_iterate (h : a ≤ b) : ∃ n, (pred^[n]) b = a :=
   exists_pred_iterate_of_le h
 #align has_le.le.exists_pred_iterate LE.le.exists_pred_iterate
+-/
 
+#print exists_pred_iterate_iff_le /-
 theorem exists_pred_iterate_iff_le : (∃ n, (pred^[n]) b = a) ↔ a ≤ b :=
   @exists_succ_iterate_iff_le αᵒᵈ _ _ _ _ _
 #align exists_pred_iterate_iff_le exists_pred_iterate_iff_le
+-/
 
+#print Pred.rec /-
 /-- Induction principle on a type with a `pred_order` for all elements below a given element `m`. -/
 @[elab_as_elim]
 theorem Pred.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, n ≤ m → P n → P (pred n)) ⦃n : α⦄
     (hmn : n ≤ m) : P n :=
   @Succ.rec αᵒᵈ _ _ _ _ _ h0 h1 _ hmn
 #align pred.rec Pred.rec
+-/
 
+#print Pred.rec_iff /-
 theorem Pred.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) {a b : α} (h : a ≤ b) :
     p a ↔ p b :=
   (@Succ.rec_iff αᵒᵈ _ _ _ _ hsucc _ _ h).symm
 #align pred.rec_iff Pred.rec_iff
+-/
 
 end PredOrder
 
@@ -1507,6 +1765,7 @@ section IsWellOrder
 
 variable [LinearOrder α]
 
+#print IsWellOrder.toIsPredArchimedean /-
 instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (· < ·)]
     [PredOrder α] : IsPredArchimedean α :=
   ⟨fun a => by
@@ -1520,10 +1779,13 @@ instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (
     refine' ⟨k + 1, _⟩
     rw [iterate_add_apply, iterate_one, hk]⟩
 #align is_well_order.to_is_pred_archimedean IsWellOrder.toIsPredArchimedean
+-/
 
+#print IsWellOrder.toIsSuccArchimedean /-
 instance (priority := 100) IsWellOrder.toIsSuccArchimedean [h : IsWellOrder α (· > ·)]
     [SuccOrder α] : IsSuccArchimedean α := by convert@OrderDual.isSuccArchimedean αᵒᵈ _ _ _
 #align is_well_order.to_is_succ_archimedean IsWellOrder.toIsSuccArchimedean
+-/
 
 end IsWellOrder
 

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

@@ -108,12 +108,6 @@ section Preorder
 
 variable [Preorder α]
 
-/- warning: succ_order.of_succ_le_iff_of_le_lt_succ -> SuccOrder.ofSuccLeIffOfLeLtSucc is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (succ a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (succ b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (SuccOrder.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (succ a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (succ b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)) -> (SuccOrder.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align succ_order.of_succ_le_iff_of_le_lt_succ SuccOrder.ofSuccLeIffOfLeLtSuccₓ'. -/
 /-- A constructor for `succ_order α` usable when `α` has no maximal element. -/
 def SuccOrder.ofSuccLeIffOfLeLtSucc (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b)
     (hle_of_lt_succ : ∀ {a b}, a < succ b → a ≤ b) : SuccOrder α :=
@@ -124,12 +118,6 @@ def SuccOrder.ofSuccLeIffOfLeLtSucc (succ : α → α) (hsucc_le_iff : ∀ {a b}
     le_of_lt_succ := fun a b => hle_of_lt_succ }
 #align succ_order.of_succ_le_iff_of_le_lt_succ SuccOrder.ofSuccLeIffOfLeLtSucc
 
-/- warning: pred_order.of_le_pred_iff_of_pred_le_pred -> PredOrder.ofLePredIffOfPredLePred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (pred b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (pred a) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (PredOrder.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (pred b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (pred a) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)) -> (PredOrder.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align pred_order.of_le_pred_iff_of_pred_le_pred PredOrder.ofLePredIffOfPredLePredₓ'. -/
 /-- A constructor for `pred_order α` usable when `α` has no minimal element. -/
 def PredOrder.ofLePredIffOfPredLePred (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b)
     (hle_of_pred_lt : ∀ {a b}, pred a < b → a ≤ b) : PredOrder α :=
@@ -146,12 +134,6 @@ section LinearOrder
 
 variable [LinearOrder α]
 
-/- warning: succ_order.of_core -> SuccOrder.ofCore is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a)) -> (forall (b : α), Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (succ a) b))) -> (forall (a : α), (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a) -> (Eq.{succ u1} α (succ a) a)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a)) -> (forall (b : α), Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (succ a) b))) -> (forall (a : α), (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a) -> (Eq.{succ u1} α (succ a) a)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align succ_order.of_core SuccOrder.ofCoreₓ'. -/
 /-- A constructor for `succ_order α` for `α` a linear order. -/
 @[simps]
 def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a < b ↔ succ a ≤ b)
@@ -165,12 +147,6 @@ def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a <
     max_of_succ_le := fun a => not_imp_not.mp fun h => by simpa using (hn h a).Not }
 #align succ_order.of_core SuccOrder.ofCore
 
-/- warning: pred_order.of_core -> PredOrder.ofCore is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_2 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a)) -> (forall (b : α), Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) b (pred a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) b a))) -> (forall (a : α), (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a) -> (Eq.{succ u1} α (pred a) a)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_2 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a)) -> (forall (b : α), Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) b (pred a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) b a))) -> (forall (a : α), (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a) -> (Eq.{succ u1} α (pred a) a)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2))))))
-Case conversion may be inaccurate. Consider using '#align pred_order.of_core PredOrder.ofCoreₓ'. -/
 /-- A constructor for `pred_order α` for `α` a linear order. -/
 @[simps]
 def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
@@ -185,12 +161,6 @@ def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
     min_of_le_pred := fun a => not_imp_not.mp fun h => by simpa using (hn h a).Not }
 #align pred_order.of_core PredOrder.ofCore
 
-/- warning: succ_order.of_succ_le_iff -> SuccOrder.ofSuccLeIff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (succ a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (succ a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align succ_order.of_succ_le_iff SuccOrder.ofSuccLeIffₓ'. -/
 /-- A constructor for `succ_order α` usable when `α` is a linear order with no maximal element. -/
 def SuccOrder.ofSuccLeIff (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b) :
     SuccOrder α :=
@@ -201,12 +171,6 @@ def SuccOrder.ofSuccLeIff (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a 
     le_of_lt_succ := fun a b h => le_of_not_lt ((not_congr hsucc_le_iff).1 h.not_le) }
 #align succ_order.of_succ_le_iff SuccOrder.ofSuccLeIff
 
-/- warning: pred_order.of_le_pred_iff -> PredOrder.ofLePredIff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (pred b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (pred b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))))
-Case conversion may be inaccurate. Consider using '#align pred_order.of_le_pred_iff PredOrder.ofLePredIffₓ'. -/
 /-- A constructor for `pred_order α` usable when `α` is a linear order with no minimal element. -/
 def PredOrder.ofLePredIff (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b) :
     PredOrder α :=
@@ -236,74 +200,32 @@ def succ : α → α :=
 #align order.succ Order.succ
 -/
 
-/- warning: order.le_succ -> Order.le_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align order.le_succ Order.le_succₓ'. -/
 theorem le_succ : ∀ a : α, a ≤ succ a :=
   SuccOrder.le_succ
 #align order.le_succ Order.le_succ
 
-/- warning: order.max_of_succ_le -> Order.max_of_succ_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.max_of_succ_le Order.max_of_succ_leₓ'. -/
 theorem max_of_succ_le {a : α} : succ a ≤ a → IsMax a :=
   SuccOrder.max_of_succ_le
 #align order.max_of_succ_le Order.max_of_succ_le
 
-/- warning: order.succ_le_of_lt -> Order.succ_le_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b)
-Case conversion may be inaccurate. Consider using '#align order.succ_le_of_lt Order.succ_le_of_ltₓ'. -/
 theorem succ_le_of_lt {a b : α} : a < b → succ a ≤ b :=
   SuccOrder.succ_le_of_lt
 #align order.succ_le_of_lt Order.succ_le_of_lt
 
-/- warning: order.le_of_lt_succ -> Order.le_of_lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.le_of_lt_succ Order.le_of_lt_succₓ'. -/
 theorem le_of_lt_succ {a b : α} : a < succ b → a ≤ b :=
   SuccOrder.le_of_lt_succ
 #align order.le_of_lt_succ Order.le_of_lt_succ
 
-/- warning: order.succ_le_iff_is_max -> Order.succ_le_iff_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.succ_le_iff_is_max Order.succ_le_iff_isMaxₓ'. -/
 @[simp]
 theorem succ_le_iff_isMax : succ a ≤ a ↔ IsMax a :=
   ⟨max_of_succ_le, fun h => h <| le_succ _⟩
 #align order.succ_le_iff_is_max Order.succ_le_iff_isMax
 
-/- warning: order.lt_succ_iff_not_is_max -> Order.lt_succ_iff_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 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 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)) (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_not_is_max Order.lt_succ_iff_not_isMaxₓ'. -/
 @[simp]
 theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a :=
   ⟨not_isMax_of_lt, fun ha => (le_succ a).lt_of_not_le fun h => ha <| max_of_succ_le h⟩
 #align order.lt_succ_iff_not_is_max Order.lt_succ_iff_not_isMax
 
-/- warning: order.lt_succ_of_not_is_max -> Order.lt_succ_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMaxₓ'. -/
 alias lt_succ_iff_not_is_max ↔ _ lt_succ_of_not_is_max
 #align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMax
 
@@ -313,62 +235,26 @@ theorem wcovby_succ (a : α) : a ⩿ succ a :=
 #align order.wcovby_succ Order.wcovby_succ
 -/
 
-/- warning: order.covby_succ_of_not_is_max -> Order.covby_succ_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align order.covby_succ_of_not_is_max Order.covby_succ_of_not_isMaxₓ'. -/
 theorem covby_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a :=
   (wcovby_succ a).covby_of_lt <| lt_succ_of_not_isMax h
 #align order.covby_succ_of_not_is_max Order.covby_succ_of_not_isMax
 
-/- warning: order.lt_succ_iff_of_not_is_max -> Order.lt_succ_iff_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b (Order.succ.{u1} α _inst_1 _inst_2 a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b (Order.succ.{u1} α _inst_1 _inst_2 a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_of_not_is_max Order.lt_succ_iff_of_not_isMaxₓ'. -/
 theorem lt_succ_iff_of_not_isMax (ha : ¬IsMax a) : b < succ a ↔ b ≤ a :=
   ⟨le_of_lt_succ, fun h => h.trans_lt <| lt_succ_of_not_isMax ha⟩
 #align order.lt_succ_iff_of_not_is_max Order.lt_succ_iff_of_not_isMax
 
-/- warning: order.succ_le_iff_of_not_is_max -> Order.succ_le_iff_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMaxₓ'. -/
 theorem succ_le_iff_of_not_isMax (ha : ¬IsMax a) : succ a ≤ b ↔ a < b :=
   ⟨(lt_succ_of_not_isMax ha).trans_le, succ_le_of_lt⟩
 #align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMax
 
-/- warning: order.succ_lt_succ_iff_of_not_is_max -> Order.succ_lt_succ_iff_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align order.succ_lt_succ_iff_of_not_is_max Order.succ_lt_succ_iff_of_not_isMaxₓ'. -/
 theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a < succ b ↔ a < b :=
   by rw [lt_succ_iff_of_not_is_max hb, succ_le_iff_of_not_is_max ha]
 #align order.succ_lt_succ_iff_of_not_is_max Order.succ_lt_succ_iff_of_not_isMax
 
-/- warning: order.succ_le_succ_iff_of_not_is_max -> Order.succ_le_succ_iff_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align order.succ_le_succ_iff_of_not_is_max Order.succ_le_succ_iff_of_not_isMaxₓ'. -/
 theorem succ_le_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a ≤ succ b ↔ a ≤ b :=
   by rw [succ_le_iff_of_not_is_max ha, lt_succ_iff_of_not_is_max hb]
 #align order.succ_le_succ_iff_of_not_is_max Order.succ_le_succ_iff_of_not_isMax
 
-/- warning: order.succ_le_succ -> Order.succ_le_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.succ_le_succ Order.succ_le_succₓ'. -/
 @[simp, mono]
 theorem succ_le_succ (h : a ≤ b) : succ a ≤ succ b :=
   by
@@ -384,24 +270,12 @@ theorem succ_mono : Monotone (succ : α → α) := fun a b => succ_le_succ
 #align order.succ_mono Order.succ_mono
 -/
 
-/- warning: order.le_succ_iterate -> Order.le_succ_iterate is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) k x)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) k x)
-Case conversion may be inaccurate. Consider using '#align order.le_succ_iterate Order.le_succ_iterateₓ'. -/
 theorem le_succ_iterate (k : ℕ) (x : α) : x ≤ (succ^[k]) x :=
   by
   conv_lhs => rw [(by simp only [Function.iterate_id, id.def] : x = (id^[k]) x)]
   exact Monotone.le_iterate_of_le succ_mono le_succ k x
 #align order.le_succ_iterate Order.le_succ_iterate
 
-/- warning: order.is_max_iterate_succ_of_eq_of_lt -> Order.isMax_iterate_succ_of_eq_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat Nat.hasLt n m) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat instLTNat n m) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
-Case conversion may be inaccurate. Consider using '#align order.is_max_iterate_succ_of_eq_of_lt Order.isMax_iterate_succ_of_eq_of_ltₓ'. -/
 theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : (succ^[n]) a = (succ^[m]) a)
     (h_lt : n < m) : IsMax ((succ^[n]) a) :=
   by
@@ -412,12 +286,6 @@ theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : (succ^[n]) a = (succ^
   exact Monotone.monotone_iterate_of_le_map succ_mono (le_succ a) h_le
 #align order.is_max_iterate_succ_of_eq_of_lt Order.isMax_iterate_succ_of_eq_of_lt
 
-/- warning: order.is_max_iterate_succ_of_eq_of_ne -> Order.isMax_iterate_succ_of_eq_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
-Case conversion may be inaccurate. Consider using '#align order.is_max_iterate_succ_of_eq_of_ne Order.isMax_iterate_succ_of_eq_of_neₓ'. -/
 theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : (succ^[n]) a = (succ^[m]) a)
     (h_ne : n ≠ m) : IsMax ((succ^[n]) a) :=
   by
@@ -427,62 +295,26 @@ theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : (succ^[n]) a = (succ^
     exact is_max_iterate_succ_of_eq_of_lt h_eq.symm (lt_of_le_of_ne h h_ne.symm)
 #align order.is_max_iterate_succ_of_eq_of_ne Order.isMax_iterate_succ_of_eq_of_ne
 
-/- warning: order.Iio_succ_of_not_is_max -> Order.Iio_succ_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a))
-Case conversion may be inaccurate. Consider using '#align order.Iio_succ_of_not_is_max Order.Iio_succ_of_not_isMaxₓ'. -/
 theorem Iio_succ_of_not_isMax (ha : ¬IsMax a) : Iio (succ a) = Iic a :=
   Set.ext fun x => lt_succ_iff_of_not_isMax ha
 #align order.Iio_succ_of_not_is_max Order.Iio_succ_of_not_isMax
 
-/- warning: order.Ici_succ_of_not_is_max -> Order.Ici_succ_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a))
-Case conversion may be inaccurate. Consider using '#align order.Ici_succ_of_not_is_max Order.Ici_succ_of_not_isMaxₓ'. -/
 theorem Ici_succ_of_not_isMax (ha : ¬IsMax a) : Ici (succ a) = Ioi a :=
   Set.ext fun x => succ_le_iff_of_not_isMax ha
 #align order.Ici_succ_of_not_is_max Order.Ici_succ_of_not_isMax
 
-/- warning: order.Ico_succ_right_of_not_is_max -> Order.Ico_succ_right_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right_of_not_is_max Order.Ico_succ_right_of_not_isMaxₓ'. -/
 theorem Ico_succ_right_of_not_isMax (hb : ¬IsMax b) : Ico a (succ b) = Icc a b := by
   rw [← Ici_inter_Iio, Iio_succ_of_not_is_max hb, Ici_inter_Iic]
 #align order.Ico_succ_right_of_not_is_max Order.Ico_succ_right_of_not_isMax
 
-/- warning: order.Ioo_succ_right_of_not_is_max -> Order.Ioo_succ_right_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right_of_not_is_max Order.Ioo_succ_right_of_not_isMaxₓ'. -/
 theorem Ioo_succ_right_of_not_isMax (hb : ¬IsMax b) : Ioo a (succ b) = Ioc a b := by
   rw [← Ioi_inter_Iio, Iio_succ_of_not_is_max hb, Ioi_inter_Iic]
 #align order.Ioo_succ_right_of_not_is_max Order.Ioo_succ_right_of_not_isMax
 
-/- warning: order.Icc_succ_left_of_not_is_max -> Order.Icc_succ_left_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Icc_succ_left_of_not_is_max Order.Icc_succ_left_of_not_isMaxₓ'. -/
 theorem Icc_succ_left_of_not_isMax (ha : ¬IsMax a) : Icc (succ a) b = Ioc a b := by
   rw [← Ici_inter_Iic, Ici_succ_of_not_is_max ha, Ioi_inter_Iic]
 #align order.Icc_succ_left_of_not_is_max Order.Icc_succ_left_of_not_isMax
 
-/- warning: order.Ico_succ_left_of_not_is_max -> Order.Ico_succ_left_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Ico_succ_left_of_not_is_max Order.Ico_succ_left_of_not_isMaxₓ'. -/
 theorem Ico_succ_left_of_not_isMax (ha : ¬IsMax a) : Ico (succ a) b = Ioo a b := by
   rw [← Ici_inter_Iio, Ici_succ_of_not_is_max ha, Ioi_inter_Iio]
 #align order.Ico_succ_left_of_not_is_max Order.Ico_succ_left_of_not_isMax
@@ -491,161 +323,65 @@ section NoMaxOrder
 
 variable [NoMaxOrder α]
 
-/- warning: order.lt_succ -> Order.lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align order.lt_succ Order.lt_succₓ'. -/
 theorem lt_succ (a : α) : a < succ a :=
   lt_succ_of_not_isMax <| not_isMax a
 #align order.lt_succ Order.lt_succ
 
-/- warning: order.lt_succ_iff -> Order.lt_succ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff Order.lt_succ_iffₓ'. -/
 @[simp]
 theorem lt_succ_iff : a < succ b ↔ a ≤ b :=
   lt_succ_iff_of_not_isMax <| not_isMax b
 #align order.lt_succ_iff Order.lt_succ_iff
 
-/- warning: order.succ_le_iff -> Order.succ_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.succ_le_iff Order.succ_le_iffₓ'. -/
 @[simp]
 theorem succ_le_iff : succ a ≤ b ↔ a < b :=
   succ_le_iff_of_not_isMax <| not_isMax a
 #align order.succ_le_iff Order.succ_le_iff
 
-/- warning: order.succ_le_succ_iff -> Order.succ_le_succ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.succ_le_succ_iff Order.succ_le_succ_iffₓ'. -/
 theorem succ_le_succ_iff : succ a ≤ succ b ↔ a ≤ b := by simp
 #align order.succ_le_succ_iff Order.succ_le_succ_iff
 
-/- warning: order.succ_lt_succ_iff -> Order.succ_lt_succ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.succ_lt_succ_iff Order.succ_lt_succ_iffₓ'. -/
 theorem succ_lt_succ_iff : succ a < succ b ↔ a < b := by simp
 #align order.succ_lt_succ_iff Order.succ_lt_succ_iff
 
-/- warning: order.le_of_succ_le_succ -> Order.le_of_succ_le_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.le_of_succ_le_succ Order.le_of_succ_le_succₓ'. -/
 alias succ_le_succ_iff ↔ le_of_succ_le_succ _
 #align order.le_of_succ_le_succ Order.le_of_succ_le_succ
 
-/- warning: order.lt_of_succ_lt_succ -> Order.lt_of_succ_lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.lt_of_succ_lt_succ Order.lt_of_succ_lt_succₓ'. -/
-/- warning: order.succ_lt_succ -> Order.succ_lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.succ_lt_succ Order.succ_lt_succₓ'. -/
 alias succ_lt_succ_iff ↔ lt_of_succ_lt_succ succ_lt_succ
 #align order.lt_of_succ_lt_succ Order.lt_of_succ_lt_succ
 #align order.succ_lt_succ Order.succ_lt_succ
 
-/- warning: order.succ_strict_mono -> Order.succ_strictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.succ.{u1} α _inst_1 _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.succ.{u1} α _inst_1 _inst_2)
-Case conversion may be inaccurate. Consider using '#align order.succ_strict_mono Order.succ_strictMonoₓ'. -/
 theorem succ_strictMono : StrictMono (succ : α → α) := fun a b => succ_lt_succ
 #align order.succ_strict_mono Order.succ_strictMono
 
-/- warning: order.covby_succ -> Order.covby_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align order.covby_succ Order.covby_succₓ'. -/
 theorem covby_succ (a : α) : a ⋖ succ a :=
   covby_succ_of_not_isMax <| not_isMax a
 #align order.covby_succ Order.covby_succ
 
-/- warning: order.Iio_succ -> Order.Iio_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align order.Iio_succ Order.Iio_succₓ'. -/
 @[simp]
 theorem Iio_succ (a : α) : Iio (succ a) = Iic a :=
   Iio_succ_of_not_isMax <| not_isMax _
 #align order.Iio_succ Order.Iio_succ
 
-/- warning: order.Ici_succ -> Order.Ici_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align order.Ici_succ Order.Ici_succₓ'. -/
 @[simp]
 theorem Ici_succ (a : α) : Ici (succ a) = Ioi a :=
   Ici_succ_of_not_isMax <| not_isMax _
 #align order.Ici_succ Order.Ici_succ
 
-/- warning: order.Ico_succ_right -> Order.Ico_succ_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right Order.Ico_succ_rightₓ'. -/
 @[simp]
 theorem Ico_succ_right (a b : α) : Ico a (succ b) = Icc a b :=
   Ico_succ_right_of_not_isMax <| not_isMax _
 #align order.Ico_succ_right Order.Ico_succ_right
 
-/- warning: order.Ioo_succ_right -> Order.Ioo_succ_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right Order.Ioo_succ_rightₓ'. -/
 @[simp]
 theorem Ioo_succ_right (a b : α) : Ioo a (succ b) = Ioc a b :=
   Ioo_succ_right_of_not_isMax <| not_isMax _
 #align order.Ioo_succ_right Order.Ioo_succ_right
 
-/- warning: order.Icc_succ_left -> Order.Icc_succ_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Icc_succ_left Order.Icc_succ_leftₓ'. -/
 @[simp]
 theorem Icc_succ_left (a b : α) : Icc (succ a) b = Ioc a b :=
   Icc_succ_left_of_not_isMax <| not_isMax _
 #align order.Icc_succ_left Order.Icc_succ_left
 
-/- warning: order.Ico_succ_left -> Order.Ico_succ_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Ico_succ_left Order.Ico_succ_leftₓ'. -/
 @[simp]
 theorem Ico_succ_left (a b : α) : Ico (succ a) b = Ioo a b :=
   Ico_succ_left_of_not_isMax <| not_isMax _
@@ -659,44 +395,20 @@ section PartialOrder
 
 variable [PartialOrder α] [SuccOrder α] {a b : α}
 
-/- warning: order.succ_eq_iff_is_max -> Order.succ_eq_iff_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.succ_eq_iff_is_max Order.succ_eq_iff_isMaxₓ'. -/
 @[simp]
 theorem succ_eq_iff_isMax : succ a = a ↔ IsMax a :=
   ⟨fun h => max_of_succ_le h.le, fun h => h.eq_of_ge <| le_succ _⟩
 #align order.succ_eq_iff_is_max Order.succ_eq_iff_isMax
 
-/- warning: is_max.succ_eq -> IsMax.succ_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
-Case conversion may be inaccurate. Consider using '#align is_max.succ_eq IsMax.succ_eqₓ'. -/
 alias succ_eq_iff_is_max ↔ _ _root_.is_max.succ_eq
 #align is_max.succ_eq IsMax.succ_eq
 
-/- warning: order.succ_eq_succ_iff_of_not_is_max -> Order.succ_eq_succ_iff_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b))
-Case conversion may be inaccurate. Consider using '#align order.succ_eq_succ_iff_of_not_is_max Order.succ_eq_succ_iff_of_not_isMaxₓ'. -/
 theorem succ_eq_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a = succ b ↔ a = b :=
   by
   rw [eq_iff_le_not_lt, eq_iff_le_not_lt, succ_le_succ_iff_of_not_is_max ha hb,
     succ_lt_succ_iff_of_not_is_max ha hb]
 #align order.succ_eq_succ_iff_of_not_is_max Order.succ_eq_succ_iff_of_not_isMax
 
-/- warning: order.le_le_succ_iff -> Order.le_le_succ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
-Case conversion may be inaccurate. Consider using '#align order.le_le_succ_iff Order.le_le_succ_iffₓ'. -/
 theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
   by
   refine'
@@ -709,22 +421,10 @@ theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
   · exact ⟨le_succ a, le_rfl⟩
 #align order.le_le_succ_iff Order.le_le_succ_iff
 
-/- warning: covby.succ_eq -> Covby.succ_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)
-Case conversion may be inaccurate. Consider using '#align covby.succ_eq Covby.succ_eqₓ'. -/
 theorem Covby.succ_eq (h : a ⋖ b) : succ a = b :=
   (succ_le_of_lt h.lt).eq_of_not_lt fun h' => h.2 (lt_succ_of_not_isMax h.lt.not_isMax) h'
 #align covby.succ_eq Covby.succ_eq
 
-/- warning: wcovby.le_succ -> Wcovby.le_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align wcovby.le_succ Wcovby.le_succₓ'. -/
 theorem Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a :=
   by
   obtain h | rfl := h.covby_or_eq
@@ -732,12 +432,6 @@ theorem Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a :=
   · exact le_succ _
 #align wcovby.le_succ Wcovby.le_succ
 
-/- warning: order.le_succ_iff_eq_or_le -> Order.le_succ_iff_eq_or_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align order.le_succ_iff_eq_or_le Order.le_succ_iff_eq_or_leₓ'. -/
 theorem le_succ_iff_eq_or_le : a ≤ succ b ↔ a = succ b ∨ a ≤ b :=
   by
   by_cases hb : IsMax b
@@ -745,12 +439,6 @@ theorem le_succ_iff_eq_or_le : a ≤ succ b ↔ a = succ b ∨ a ≤ b :=
   · rw [← lt_succ_iff_of_not_is_max hb, le_iff_eq_or_lt]
 #align order.le_succ_iff_eq_or_le Order.le_succ_iff_eq_or_le
 
-/- warning: order.lt_succ_iff_eq_or_lt_of_not_is_max -> Order.lt_succ_iff_eq_or_lt_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_eq_or_lt_of_not_is_max Order.lt_succ_iff_eq_or_lt_of_not_isMaxₓ'. -/
 theorem lt_succ_iff_eq_or_lt_of_not_isMax (hb : ¬IsMax b) : a < succ b ↔ a = b ∨ a < b :=
   (lt_succ_iff_of_not_isMax hb).trans le_iff_eq_or_lt
 #align order.lt_succ_iff_eq_or_lt_of_not_is_max Order.lt_succ_iff_eq_or_lt_of_not_isMax
@@ -761,53 +449,23 @@ theorem Iic_succ (a : α) : Iic (succ a) = insert (succ a) (Iic a) :=
 #align order.Iic_succ Order.Iic_succ
 -/
 
-/- warning: order.Icc_succ_right -> Order.Icc_succ_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Icc_succ_right Order.Icc_succ_rightₓ'. -/
 theorem Icc_succ_right (h : a ≤ succ b) : Icc a (succ b) = insert (succ b) (Icc a b) := by
   simp_rw [← Ici_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ici.2 h)]
 #align order.Icc_succ_right Order.Icc_succ_right
 
-/- warning: order.Ioc_succ_right -> Order.Ioc_succ_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ioc_succ_right Order.Ioc_succ_rightₓ'. -/
 theorem Ioc_succ_right (h : a < succ b) : Ioc a (succ b) = insert (succ b) (Ioc a b) := by
   simp_rw [← Ioi_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ioi.2 h)]
 #align order.Ioc_succ_right Order.Ioc_succ_right
 
-/- warning: order.Iio_succ_eq_insert_of_not_is_max -> Order.Iio_succ_eq_insert_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
-Case conversion may be inaccurate. Consider using '#align order.Iio_succ_eq_insert_of_not_is_max Order.Iio_succ_eq_insert_of_not_isMaxₓ'. -/
 theorem Iio_succ_eq_insert_of_not_isMax (h : ¬IsMax a) : Iio (succ a) = insert a (Iio a) :=
   ext fun _ => lt_succ_iff_eq_or_lt_of_not_isMax h
 #align order.Iio_succ_eq_insert_of_not_is_max Order.Iio_succ_eq_insert_of_not_isMax
 
-/- warning: order.Ico_succ_right_eq_insert_of_not_is_max -> Order.Ico_succ_right_eq_insert_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right_eq_insert_of_not_is_max Order.Ico_succ_right_eq_insert_of_not_isMaxₓ'. -/
 theorem Ico_succ_right_eq_insert_of_not_isMax (h₁ : a ≤ b) (h₂ : ¬IsMax b) :
     Ico a (succ b) = insert b (Ico a b) := by
   simp_rw [← Iio_inter_Ici, Iio_succ_eq_insert_of_not_is_max h₂, insert_inter_of_mem (mem_Ici.2 h₁)]
 #align order.Ico_succ_right_eq_insert_of_not_is_max Order.Ico_succ_right_eq_insert_of_not_isMax
 
-/- warning: order.Ioo_succ_right_eq_insert_of_not_is_max -> Order.Ioo_succ_right_eq_insert_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right_eq_insert_of_not_is_max Order.Ioo_succ_right_eq_insert_of_not_isMaxₓ'. -/
 theorem Ioo_succ_right_eq_insert_of_not_isMax (h₁ : a < b) (h₂ : ¬IsMax b) :
     Ioo a (succ b) = insert b (Ioo a b) := by
   simp_rw [← Iio_inter_Ioi, Iio_succ_eq_insert_of_not_is_max h₂, insert_inter_of_mem (mem_Ioi.2 h₁)]
@@ -817,91 +475,37 @@ section NoMaxOrder
 
 variable [NoMaxOrder α]
 
-/- warning: order.succ_eq_succ_iff -> Order.succ_eq_succ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align order.succ_eq_succ_iff Order.succ_eq_succ_iffₓ'. -/
 @[simp]
 theorem succ_eq_succ_iff : succ a = succ b ↔ a = b :=
   succ_eq_succ_iff_of_not_isMax (not_isMax a) (not_isMax b)
 #align order.succ_eq_succ_iff Order.succ_eq_succ_iff
 
-/- warning: order.succ_injective -> Order.succ_injective is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
-Case conversion may be inaccurate. Consider using '#align order.succ_injective Order.succ_injectiveₓ'. -/
 theorem succ_injective : Injective (succ : α → α) := fun a b => succ_eq_succ_iff.1
 #align order.succ_injective Order.succ_injective
 
-/- warning: order.succ_ne_succ_iff -> Order.succ_ne_succ_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align order.succ_ne_succ_iff Order.succ_ne_succ_iffₓ'. -/
 theorem succ_ne_succ_iff : succ a ≠ succ b ↔ a ≠ b :=
   succ_injective.ne_iff
 #align order.succ_ne_succ_iff Order.succ_ne_succ_iff
 
-/- warning: order.succ_ne_succ -> Order.succ_ne_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.succ_ne_succ Order.succ_ne_succₓ'. -/
 alias succ_ne_succ_iff ↔ _ succ_ne_succ
 #align order.succ_ne_succ Order.succ_ne_succ
 
-/- warning: order.lt_succ_iff_eq_or_lt -> Order.lt_succ_iff_eq_or_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_eq_or_lt Order.lt_succ_iff_eq_or_ltₓ'. -/
 theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b :=
   lt_succ_iff.trans le_iff_eq_or_lt
 #align order.lt_succ_iff_eq_or_lt Order.lt_succ_iff_eq_or_lt
 
-/- warning: order.succ_eq_iff_covby -> Order.succ_eq_iff_covby is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
-Case conversion may be inaccurate. Consider using '#align order.succ_eq_iff_covby Order.succ_eq_iff_covbyₓ'. -/
 theorem succ_eq_iff_covby : succ a = b ↔ a ⋖ b :=
   ⟨by rintro rfl; exact covby_succ _, Covby.succ_eq⟩
 #align order.succ_eq_iff_covby Order.succ_eq_iff_covby
 
-/- warning: order.Iio_succ_eq_insert -> Order.Iio_succ_eq_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align order.Iio_succ_eq_insert Order.Iio_succ_eq_insertₓ'. -/
 theorem Iio_succ_eq_insert (a : α) : Iio (succ a) = insert a (Iio a) :=
   Iio_succ_eq_insert_of_not_isMax <| not_isMax a
 #align order.Iio_succ_eq_insert Order.Iio_succ_eq_insert
 
-/- warning: order.Ico_succ_right_eq_insert -> Order.Ico_succ_right_eq_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right_eq_insert Order.Ico_succ_right_eq_insertₓ'. -/
 theorem Ico_succ_right_eq_insert (h : a ≤ b) : Ico a (succ b) = insert b (Ico a b) :=
   Ico_succ_right_eq_insert_of_not_isMax h <| not_isMax b
 #align order.Ico_succ_right_eq_insert Order.Ico_succ_right_eq_insert
 
-/- warning: order.Ioo_succ_right_eq_insert -> Order.Ioo_succ_right_eq_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right_eq_insert Order.Ioo_succ_right_eq_insertₓ'. -/
 theorem Ioo_succ_right_eq_insert (h : a < b) : Ioo a (succ b) = insert b (Ioo a b) :=
   Ioo_succ_right_eq_insert_of_not_isMax h <| not_isMax b
 #align order.Ioo_succ_right_eq_insert Order.Ioo_succ_right_eq_insert
@@ -912,34 +516,16 @@ section OrderTop
 
 variable [OrderTop α]
 
-/- warning: order.succ_top -> Order.succ_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-Case conversion may be inaccurate. Consider using '#align order.succ_top Order.succ_topₓ'. -/
 @[simp]
 theorem succ_top : succ (⊤ : α) = ⊤ :=
   isMax_top.succ_eq
 #align order.succ_top Order.succ_top
 
-/- warning: order.succ_le_iff_eq_top -> Order.succ_le_iff_eq_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-Case conversion may be inaccurate. Consider using '#align order.succ_le_iff_eq_top Order.succ_le_iff_eq_topₓ'. -/
 @[simp]
 theorem succ_le_iff_eq_top : succ a ≤ a ↔ a = ⊤ :=
   succ_le_iff_isMax.trans isMax_iff_eq_top
 #align order.succ_le_iff_eq_top Order.succ_le_iff_eq_top
 
-/- warning: order.lt_succ_iff_ne_top -> Order.lt_succ_iff_ne_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_ne_top Order.lt_succ_iff_ne_topₓ'. -/
 @[simp]
 theorem lt_succ_iff_ne_top : a < succ a ↔ a ≠ ⊤ :=
   lt_succ_iff_not_isMax.trans not_isMax_iff_ne_top
@@ -951,44 +537,20 @@ section OrderBot
 
 variable [OrderBot α]
 
-/- warning: order.lt_succ_bot_iff -> Order.lt_succ_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-Case conversion may be inaccurate. Consider using '#align order.lt_succ_bot_iff Order.lt_succ_bot_iffₓ'. -/
 @[simp]
 theorem lt_succ_bot_iff [NoMaxOrder α] : a < succ ⊥ ↔ a = ⊥ := by rw [lt_succ_iff, le_bot_iff]
 #align order.lt_succ_bot_iff Order.lt_succ_bot_iff
 
-/- warning: order.le_succ_bot_iff -> Order.le_succ_bot_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Or (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Or (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align order.le_succ_bot_iff Order.le_succ_bot_iffₓ'. -/
 theorem le_succ_bot_iff : a ≤ succ ⊥ ↔ a = ⊥ ∨ a = succ ⊥ := by
   rw [le_succ_iff_eq_or_le, le_bot_iff, or_comm']
 #align order.le_succ_bot_iff Order.le_succ_bot_iff
 
 variable [Nontrivial α]
 
-/- warning: order.bot_lt_succ -> Order.bot_lt_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)
-Case conversion may be inaccurate. Consider using '#align order.bot_lt_succ Order.bot_lt_succₓ'. -/
 theorem bot_lt_succ (a : α) : ⊥ < succ a :=
   (lt_succ_of_not_isMax not_isMax_bot).trans_le <| succ_mono bot_le
 #align order.bot_lt_succ Order.bot_lt_succ
 
-/- warning: order.succ_ne_bot -> Order.succ_ne_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-Case conversion may be inaccurate. Consider using '#align order.succ_ne_bot Order.succ_ne_botₓ'. -/
 theorem succ_ne_bot (a : α) : succ a ≠ ⊥ :=
   (bot_lt_succ a).ne'
 #align order.succ_ne_bot Order.succ_ne_bot
@@ -1010,12 +572,6 @@ section CompleteLattice
 
 variable [CompleteLattice α] [SuccOrder α]
 
-/- warning: order.succ_eq_infi -> Order.succ_eq_iInf is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iInf.{u1, succ u1} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) α (fun (b : α) => iInf.{u1, 0} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iInf.{u1, succ u1} α (CompleteLattice.toInfSet.{u1} α _inst_1) α (fun (b : α) => iInf.{u1, 0} α (CompleteLattice.toInfSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
-Case conversion may be inaccurate. Consider using '#align order.succ_eq_infi Order.succ_eq_iInfₓ'. -/
 theorem succ_eq_iInf (a : α) : succ a = ⨅ (b) (h : a < b), b :=
   by
   refine' le_antisymm (le_iInf fun b => le_iInf succ_le_of_lt) _
@@ -1042,74 +598,32 @@ def pred : α → α :=
 #align order.pred Order.pred
 -/
 
-/- warning: order.pred_le -> Order.pred_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
-Case conversion may be inaccurate. Consider using '#align order.pred_le Order.pred_leₓ'. -/
 theorem pred_le : ∀ a : α, pred a ≤ a :=
   PredOrder.pred_le
 #align order.pred_le Order.pred_le
 
-/- warning: order.min_of_le_pred -> Order.min_of_le_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.min_of_le_pred Order.min_of_le_predₓ'. -/
 theorem min_of_le_pred {a : α} : a ≤ pred a → IsMin a :=
   PredOrder.min_of_le_pred
 #align order.min_of_le_pred Order.min_of_le_pred
 
-/- warning: order.le_pred_of_lt -> Order.le_pred_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.le_pred_of_lt Order.le_pred_of_ltₓ'. -/
 theorem le_pred_of_lt {a b : α} : a < b → a ≤ pred b :=
   PredOrder.le_pred_of_lt
 #align order.le_pred_of_lt Order.le_pred_of_lt
 
-/- warning: order.le_of_pred_lt -> Order.le_of_pred_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.le_of_pred_lt Order.le_of_pred_ltₓ'. -/
 theorem le_of_pred_lt {a b : α} : pred a < b → a ≤ b :=
   PredOrder.le_of_pred_lt
 #align order.le_of_pred_lt Order.le_of_pred_lt
 
-/- warning: order.le_pred_iff_is_min -> Order.le_pred_iff_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.le_pred_iff_is_min Order.le_pred_iff_isMinₓ'. -/
 @[simp]
 theorem le_pred_iff_isMin : a ≤ pred a ↔ IsMin a :=
   ⟨min_of_le_pred, fun h => h <| pred_le _⟩
 #align order.le_pred_iff_is_min Order.le_pred_iff_isMin
 
-/- warning: order.pred_lt_iff_not_is_min -> Order.pred_lt_iff_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) 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 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a) (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_not_is_min Order.pred_lt_iff_not_isMinₓ'. -/
 @[simp]
 theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a :=
   ⟨not_isMin_of_lt, fun ha => (pred_le a).lt_of_not_le fun h => ha <| min_of_le_pred h⟩
 #align order.pred_lt_iff_not_is_min Order.pred_lt_iff_not_isMin
 
-/- warning: order.pred_lt_of_not_is_min -> Order.pred_lt_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMinₓ'. -/
 alias pred_lt_iff_not_is_min ↔ _ pred_lt_of_not_is_min
 #align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMin
 
@@ -1119,42 +633,18 @@ theorem pred_wcovby (a : α) : pred a ⩿ a :=
 #align order.pred_wcovby Order.pred_wcovby
 -/
 
-/- warning: order.pred_covby_of_not_is_min -> Order.pred_covby_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
-Case conversion may be inaccurate. Consider using '#align order.pred_covby_of_not_is_min Order.pred_covby_of_not_isMinₓ'. -/
 theorem pred_covby_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a :=
   (pred_wcovby a).covby_of_lt <| pred_lt_of_not_isMin h
 #align order.pred_covby_of_not_is_min Order.pred_covby_of_not_isMin
 
-/- warning: order.pred_lt_iff_of_not_is_min -> Order.pred_lt_iff_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_of_not_is_min Order.pred_lt_iff_of_not_isMinₓ'. -/
 theorem pred_lt_iff_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a ≤ b :=
   ⟨le_of_pred_lt, (pred_lt_of_not_isMin ha).trans_le⟩
 #align order.pred_lt_iff_of_not_is_min Order.pred_lt_iff_of_not_isMin
 
-/- warning: order.le_pred_iff_of_not_is_min -> Order.le_pred_iff_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (Order.pred.{u1} α _inst_1 _inst_2 a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (Order.pred.{u1} α _inst_1 _inst_2 a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
-Case conversion may be inaccurate. Consider using '#align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMinₓ'. -/
 theorem le_pred_iff_of_not_isMin (ha : ¬IsMin a) : b ≤ pred a ↔ b < a :=
   ⟨fun h => h.trans_lt <| pred_lt_of_not_isMin ha, le_pred_of_lt⟩
 #align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMin
 
-/- warning: order.pred_le_pred -> Order.pred_le_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.pred_le_pred Order.pred_le_predₓ'. -/
 @[simp, mono]
 theorem pred_le_pred {a b : α} (h : a ≤ b) : pred a ≤ pred b :=
   succ_le_succ h.dual
@@ -1165,96 +655,42 @@ theorem pred_mono : Monotone (pred : α → α) := fun a b => pred_le_pred
 #align order.pred_mono Order.pred_mono
 -/
 
-/- warning: order.pred_iterate_le -> Order.pred_iterate_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) k x) x
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) k x) x
-Case conversion may be inaccurate. Consider using '#align order.pred_iterate_le Order.pred_iterate_leₓ'. -/
 theorem pred_iterate_le (k : ℕ) (x : α) : (pred^[k]) x ≤ x :=
   by
   conv_rhs => rw [(by simp only [Function.iterate_id, id.def] : x = (id^[k]) x)]
   exact Monotone.iterate_le_of_le pred_mono pred_le k x
 #align order.pred_iterate_le Order.pred_iterate_le
 
-/- warning: order.is_min_iterate_pred_of_eq_of_lt -> Order.isMin_iterate_pred_of_eq_of_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat Nat.hasLt n m) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat instLTNat n m) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
-Case conversion may be inaccurate. Consider using '#align order.is_min_iterate_pred_of_eq_of_lt Order.isMin_iterate_pred_of_eq_of_ltₓ'. -/
 theorem isMin_iterate_pred_of_eq_of_lt {n m : ℕ} (h_eq : (pred^[n]) a = (pred^[m]) a)
     (h_lt : n < m) : IsMin ((pred^[n]) a) :=
   @isMax_iterate_succ_of_eq_of_lt αᵒᵈ _ _ _ _ _ h_eq h_lt
 #align order.is_min_iterate_pred_of_eq_of_lt Order.isMin_iterate_pred_of_eq_of_lt
 
-/- warning: order.is_min_iterate_pred_of_eq_of_ne -> Order.isMin_iterate_pred_of_eq_of_ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
-Case conversion may be inaccurate. Consider using '#align order.is_min_iterate_pred_of_eq_of_ne Order.isMin_iterate_pred_of_eq_of_neₓ'. -/
 theorem isMin_iterate_pred_of_eq_of_ne {n m : ℕ} (h_eq : (pred^[n]) a = (pred^[m]) a)
     (h_ne : n ≠ m) : IsMin ((pred^[n]) a) :=
   @isMax_iterate_succ_of_eq_of_ne αᵒᵈ _ _ _ _ _ h_eq h_ne
 #align order.is_min_iterate_pred_of_eq_of_ne Order.isMin_iterate_pred_of_eq_of_ne
 
-/- warning: order.Ioi_pred_of_not_is_min -> Order.Ioi_pred_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a))
-Case conversion may be inaccurate. Consider using '#align order.Ioi_pred_of_not_is_min Order.Ioi_pred_of_not_isMinₓ'. -/
 theorem Ioi_pred_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = Ici a :=
   Set.ext fun x => pred_lt_iff_of_not_isMin ha
 #align order.Ioi_pred_of_not_is_min Order.Ioi_pred_of_not_isMin
 
-/- warning: order.Iic_pred_of_not_is_min -> Order.Iic_pred_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a))
-Case conversion may be inaccurate. Consider using '#align order.Iic_pred_of_not_is_min Order.Iic_pred_of_not_isMinₓ'. -/
 theorem Iic_pred_of_not_isMin (ha : ¬IsMin a) : Iic (pred a) = Iio a :=
   Set.ext fun x => le_pred_iff_of_not_isMin ha
 #align order.Iic_pred_of_not_is_min Order.Iic_pred_of_not_isMin
 
-/- warning: order.Ioc_pred_left_of_not_is_min -> Order.Ioc_pred_left_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_left_of_not_is_min Order.Ioc_pred_left_of_not_isMinₓ'. -/
 theorem Ioc_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioc (pred a) b = Icc a b := by
   rw [← Ioi_inter_Iic, Ioi_pred_of_not_is_min ha, Ici_inter_Iic]
 #align order.Ioc_pred_left_of_not_is_min Order.Ioc_pred_left_of_not_isMin
 
-/- warning: order.Ioo_pred_left_of_not_is_min -> Order.Ioo_pred_left_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Ioo_pred_left_of_not_is_min Order.Ioo_pred_left_of_not_isMinₓ'. -/
 theorem Ioo_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioo (pred a) b = Ico a b := by
   rw [← Ioi_inter_Iio, Ioi_pred_of_not_is_min ha, Ici_inter_Iio]
 #align order.Ioo_pred_left_of_not_is_min Order.Ioo_pred_left_of_not_isMin
 
-/- warning: order.Icc_pred_right_of_not_is_min -> Order.Icc_pred_right_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Icc_pred_right_of_not_is_min Order.Icc_pred_right_of_not_isMinₓ'. -/
 theorem Icc_pred_right_of_not_isMin (ha : ¬IsMin b) : Icc a (pred b) = Ico a b := by
   rw [← Ici_inter_Iic, Iic_pred_of_not_is_min ha, Ici_inter_Iio]
 #align order.Icc_pred_right_of_not_is_min Order.Icc_pred_right_of_not_isMin
 
-/- warning: order.Ioc_pred_right_of_not_is_min -> Order.Ioc_pred_right_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b))
-Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_right_of_not_is_min Order.Ioc_pred_right_of_not_isMinₓ'. -/
 theorem Ioc_pred_right_of_not_isMin (ha : ¬IsMin b) : Ioc a (pred b) = Ioo a b := by
   rw [← Ioi_inter_Iic, Iic_pred_of_not_is_min ha, Ioi_inter_Iio]
 #align order.Ioc_pred_right_of_not_is_min Order.Ioc_pred_right_of_not_isMin
@@ -1263,161 +699,65 @@ section NoMinOrder
 
 variable [NoMinOrder α]
 
-/- warning: order.pred_lt -> Order.pred_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
-Case conversion may be inaccurate. Consider using '#align order.pred_lt Order.pred_ltₓ'. -/
 theorem pred_lt (a : α) : pred a < a :=
   pred_lt_of_not_isMin <| not_isMin a
 #align order.pred_lt Order.pred_lt
 
-/- warning: order.pred_lt_iff -> Order.pred_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff Order.pred_lt_iffₓ'. -/
 @[simp]
 theorem pred_lt_iff : pred a < b ↔ a ≤ b :=
   pred_lt_iff_of_not_isMin <| not_isMin a
 #align order.pred_lt_iff Order.pred_lt_iff
 
-/- warning: order.le_pred_iff -> Order.le_pred_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.le_pred_iff Order.le_pred_iffₓ'. -/
 @[simp]
 theorem le_pred_iff : a ≤ pred b ↔ a < b :=
   le_pred_iff_of_not_isMin <| not_isMin b
 #align order.le_pred_iff Order.le_pred_iff
 
-/- warning: order.pred_le_pred_iff -> Order.pred_le_pred_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.pred_le_pred_iff Order.pred_le_pred_iffₓ'. -/
 theorem pred_le_pred_iff : pred a ≤ pred b ↔ a ≤ b := by simp
 #align order.pred_le_pred_iff Order.pred_le_pred_iff
 
-/- warning: order.pred_lt_pred_iff -> Order.pred_lt_pred_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_pred_iff Order.pred_lt_pred_iffₓ'. -/
 theorem pred_lt_pred_iff : pred a < pred b ↔ a < b := by simp
 #align order.pred_lt_pred_iff Order.pred_lt_pred_iff
 
-/- warning: order.le_of_pred_le_pred -> Order.le_of_pred_le_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.le_of_pred_le_pred Order.le_of_pred_le_predₓ'. -/
 alias pred_le_pred_iff ↔ le_of_pred_le_pred _
 #align order.le_of_pred_le_pred Order.le_of_pred_le_pred
 
-/- warning: order.lt_of_pred_lt_pred -> Order.lt_of_pred_lt_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align order.lt_of_pred_lt_pred Order.lt_of_pred_lt_predₓ'. -/
-/- warning: order.pred_lt_pred -> Order.pred_lt_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_pred Order.pred_lt_predₓ'. -/
 alias pred_lt_pred_iff ↔ lt_of_pred_lt_pred pred_lt_pred
 #align order.lt_of_pred_lt_pred Order.lt_of_pred_lt_pred
 #align order.pred_lt_pred Order.pred_lt_pred
 
-/- warning: order.pred_strict_mono -> Order.pred_strictMono is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.pred.{u1} α _inst_1 _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.pred.{u1} α _inst_1 _inst_2)
-Case conversion may be inaccurate. Consider using '#align order.pred_strict_mono Order.pred_strictMonoₓ'. -/
 theorem pred_strictMono : StrictMono (pred : α → α) := fun a b => pred_lt_pred
 #align order.pred_strict_mono Order.pred_strictMono
 
-/- warning: order.pred_covby -> Order.pred_covby is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
-Case conversion may be inaccurate. Consider using '#align order.pred_covby Order.pred_covbyₓ'. -/
 theorem pred_covby (a : α) : pred a ⋖ a :=
   pred_covby_of_not_isMin <| not_isMin a
 #align order.pred_covby Order.pred_covby
 
-/- warning: order.Ioi_pred -> Order.Ioi_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align order.Ioi_pred Order.Ioi_predₓ'. -/
 @[simp]
 theorem Ioi_pred (a : α) : Ioi (pred a) = Ici a :=
   Ioi_pred_of_not_isMin <| not_isMin a
 #align order.Ioi_pred Order.Ioi_pred
 
-/- warning: order.Iic_pred -> Order.Iic_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a)
-Case conversion may be inaccurate. Consider using '#align order.Iic_pred Order.Iic_predₓ'. -/
 @[simp]
 theorem Iic_pred (a : α) : Iic (pred a) = Iio a :=
   Iic_pred_of_not_isMin <| not_isMin a
 #align order.Iic_pred Order.Iic_pred
 
-/- warning: order.Ioc_pred_left -> Order.Ioc_pred_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_left Order.Ioc_pred_leftₓ'. -/
 @[simp]
 theorem Ioc_pred_left (a b : α) : Ioc (pred a) b = Icc a b :=
   Ioc_pred_left_of_not_isMin <| not_isMin _
 #align order.Ioc_pred_left Order.Ioc_pred_left
 
-/- warning: order.Ioo_pred_left -> Order.Ioo_pred_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Ioo_pred_left Order.Ioo_pred_leftₓ'. -/
 @[simp]
 theorem Ioo_pred_left (a b : α) : Ioo (pred a) b = Ico a b :=
   Ioo_pred_left_of_not_isMin <| not_isMin _
 #align order.Ioo_pred_left Order.Ioo_pred_left
 
-/- warning: order.Icc_pred_right -> Order.Icc_pred_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Icc_pred_right Order.Icc_pred_rightₓ'. -/
 @[simp]
 theorem Icc_pred_right (a b : α) : Icc a (pred b) = Ico a b :=
   Icc_pred_right_of_not_isMin <| not_isMin _
 #align order.Icc_pred_right Order.Icc_pred_right
 
-/- warning: order.Ioc_pred_right -> Order.Ioc_pred_right is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b)
-Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_right Order.Ioc_pred_rightₓ'. -/
 @[simp]
 theorem Ioc_pred_right (a b : α) : Ioc a (pred b) = Ioo a b :=
   Ioc_pred_right_of_not_isMin <| not_isMin _
@@ -1431,32 +771,14 @@ section PartialOrder
 
 variable [PartialOrder α] [PredOrder α] {a b : α}
 
-/- warning: order.pred_eq_iff_is_min -> Order.pred_eq_iff_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.pred_eq_iff_is_min Order.pred_eq_iff_isMinₓ'. -/
 @[simp]
 theorem pred_eq_iff_isMin : pred a = a ↔ IsMin a :=
   ⟨fun h => min_of_le_pred h.ge, fun h => h.eq_of_le <| pred_le _⟩
 #align order.pred_eq_iff_is_min Order.pred_eq_iff_isMin
 
-/- warning: is_min.pred_eq -> IsMin.pred_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
-Case conversion may be inaccurate. Consider using '#align is_min.pred_eq IsMin.pred_eqₓ'. -/
 alias pred_eq_iff_is_min ↔ _ _root_.is_min.pred_eq
 #align is_min.pred_eq IsMin.pred_eq
 
-/- warning: order.pred_le_le_iff -> Order.pred_le_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a)) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a)) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
-Case conversion may be inaccurate. Consider using '#align order.pred_le_le_iff Order.pred_le_le_iffₓ'. -/
 theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a :=
   by
   refine'
@@ -1467,22 +789,10 @@ theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = p
   · exact ⟨le_rfl, pred_le a⟩
 #align order.pred_le_le_iff Order.pred_le_le_iff
 
-/- warning: covby.pred_eq -> Covby.pred_eq is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
-Case conversion may be inaccurate. Consider using '#align covby.pred_eq Covby.pred_eqₓ'. -/
 theorem Covby.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
   (le_pred_of_lt h.lt).eq_of_not_gt fun h' => h.2 h' <| pred_lt_of_not_isMin h.lt.not_isMin
 #align covby.pred_eq Covby.pred_eq
 
-/- warning: wcovby.pred_le -> Wcovby.pred_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
-Case conversion may be inaccurate. Consider using '#align wcovby.pred_le Wcovby.pred_leₓ'. -/
 theorem Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a :=
   by
   obtain h | rfl := h.covby_or_eq
@@ -1490,12 +800,6 @@ theorem Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a :=
   · exact pred_le _
 #align wcovby.pred_le Wcovby.pred_le
 
-/- warning: order.pred_le_iff_eq_or_le -> Order.pred_le_iff_eq_or_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align order.pred_le_iff_eq_or_le Order.pred_le_iff_eq_or_leₓ'. -/
 theorem pred_le_iff_eq_or_le : pred a ≤ b ↔ b = pred a ∨ a ≤ b :=
   by
   by_cases ha : IsMin a
@@ -1503,12 +807,6 @@ theorem pred_le_iff_eq_or_le : pred a ≤ b ↔ b = pred a ∨ a ≤ b :=
   · rw [← pred_lt_iff_of_not_is_min ha, le_iff_eq_or_lt, eq_comm]
 #align order.pred_le_iff_eq_or_le Order.pred_le_iff_eq_or_le
 
-/- warning: order.pred_lt_iff_eq_or_lt_of_not_is_min -> Order.pred_lt_iff_eq_or_lt_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_eq_or_lt_of_not_is_min Order.pred_lt_iff_eq_or_lt_of_not_isMinₓ'. -/
 theorem pred_lt_iff_eq_or_lt_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a = b ∨ a < b :=
   (pred_lt_iff_of_not_isMin ha).trans le_iff_eq_or_lt
 #align order.pred_lt_iff_eq_or_lt_of_not_is_min Order.pred_lt_iff_eq_or_lt_of_not_isMin
@@ -1519,34 +817,16 @@ theorem Ici_pred (a : α) : Ici (pred a) = insert (pred a) (Ici a) :=
 #align order.Ici_pred Order.Ici_pred
 -/
 
-/- warning: order.Ioi_pred_eq_insert_of_not_is_min -> Order.Ioi_pred_eq_insert_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
-Case conversion may be inaccurate. Consider using '#align order.Ioi_pred_eq_insert_of_not_is_min Order.Ioi_pred_eq_insert_of_not_isMinₓ'. -/
 theorem Ioi_pred_eq_insert_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = insert a (Ioi a) :=
   by
   ext x; simp only [insert, mem_set_of, @eq_comm _ x a]
   exact pred_lt_iff_eq_or_lt_of_not_is_min ha
 #align order.Ioi_pred_eq_insert_of_not_is_min Order.Ioi_pred_eq_insert_of_not_isMin
 
-/- warning: order.Icc_pred_left -> Order.Icc_pred_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Icc_pred_left Order.Icc_pred_leftₓ'. -/
 theorem Icc_pred_left (h : pred a ≤ b) : Icc (pred a) b = insert (pred a) (Icc a b) := by
   simp_rw [← Ici_inter_Iic, Ici_pred, insert_inter_of_mem (mem_Iic.2 h)]
 #align order.Icc_pred_left Order.Icc_pred_left
 
-/- warning: order.Ico_pred_left -> Order.Ico_pred_left is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ico_pred_left Order.Ico_pred_leftₓ'. -/
 theorem Ico_pred_left (h : pred a < b) : Ico (pred a) b = insert (pred a) (Ico a b) := by
   simp_rw [← Ici_inter_Iio, Ici_pred, insert_inter_of_mem (mem_Iio.2 h)]
 #align order.Ico_pred_left Order.Ico_pred_left
@@ -1555,91 +835,37 @@ section NoMinOrder
 
 variable [NoMinOrder α]
 
-/- warning: order.pred_eq_pred_iff -> Order.pred_eq_pred_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align order.pred_eq_pred_iff Order.pred_eq_pred_iffₓ'. -/
 @[simp]
 theorem pred_eq_pred_iff : pred a = pred b ↔ a = b := by
   simp_rw [eq_iff_le_not_lt, pred_le_pred_iff, pred_lt_pred_iff]
 #align order.pred_eq_pred_iff Order.pred_eq_pred_iff
 
-/- warning: order.pred_injective -> Order.pred_injective is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
-Case conversion may be inaccurate. Consider using '#align order.pred_injective Order.pred_injectiveₓ'. -/
 theorem pred_injective : Injective (pred : α → α) := fun a b => pred_eq_pred_iff.1
 #align order.pred_injective Order.pred_injective
 
-/- warning: order.pred_ne_pred_iff -> Order.pred_ne_pred_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
-Case conversion may be inaccurate. Consider using '#align order.pred_ne_pred_iff Order.pred_ne_pred_iffₓ'. -/
 theorem pred_ne_pred_iff : pred a ≠ pred b ↔ a ≠ b :=
   pred_injective.ne_iff
 #align order.pred_ne_pred_iff Order.pred_ne_pred_iff
 
-/- warning: order.pred_ne_pred -> Order.pred_ne_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.pred_ne_pred Order.pred_ne_predₓ'. -/
 alias pred_ne_pred_iff ↔ _ pred_ne_pred
 #align order.pred_ne_pred Order.pred_ne_pred
 
-/- warning: order.pred_lt_iff_eq_or_lt -> Order.pred_lt_iff_eq_or_lt is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_eq_or_lt Order.pred_lt_iff_eq_or_ltₓ'. -/
 theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b :=
   pred_lt_iff.trans le_iff_eq_or_lt
 #align order.pred_lt_iff_eq_or_lt Order.pred_lt_iff_eq_or_lt
 
-/- warning: order.pred_eq_iff_covby -> Order.pred_eq_iff_covby is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
-Case conversion may be inaccurate. Consider using '#align order.pred_eq_iff_covby Order.pred_eq_iff_covbyₓ'. -/
 theorem pred_eq_iff_covby : pred b = a ↔ a ⋖ b :=
   ⟨by rintro rfl; exact pred_covby _, Covby.pred_eq⟩
 #align order.pred_eq_iff_covby Order.pred_eq_iff_covby
 
-/- warning: order.Ioi_pred_eq_insert -> Order.Ioi_pred_eq_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
-Case conversion may be inaccurate. Consider using '#align order.Ioi_pred_eq_insert Order.Ioi_pred_eq_insertₓ'. -/
 theorem Ioi_pred_eq_insert (a : α) : Ioi (pred a) = insert a (Ioi a) :=
   ext fun _ => pred_lt_iff_eq_or_lt.trans <| or_congr_left eq_comm
 #align order.Ioi_pred_eq_insert Order.Ioi_pred_eq_insert
 
-/- warning: order.Ico_pred_right_eq_insert -> Order.Ico_pred_right_eq_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ico_pred_right_eq_insert Order.Ico_pred_right_eq_insertₓ'. -/
 theorem Ico_pred_right_eq_insert (h : a ≤ b) : Ioc (pred a) b = insert a (Ioc a b) := by
   simp_rw [← Ioi_inter_Iic, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iic.2 h)]
 #align order.Ico_pred_right_eq_insert Order.Ico_pred_right_eq_insert
 
-/- warning: order.Ioo_pred_right_eq_insert -> Order.Ioo_pred_right_eq_insert is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
-Case conversion may be inaccurate. Consider using '#align order.Ioo_pred_right_eq_insert Order.Ioo_pred_right_eq_insertₓ'. -/
 theorem Ioo_pred_right_eq_insert (h : a < b) : Ioo (pred a) b = insert a (Ioo a b) := by
   simp_rw [← Ioi_inter_Iio, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iio.2 h)]
 #align order.Ioo_pred_right_eq_insert Order.Ioo_pred_right_eq_insert
@@ -1650,34 +876,16 @@ section OrderBot
 
 variable [OrderBot α]
 
-/- warning: order.pred_bot -> Order.pred_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-Case conversion may be inaccurate. Consider using '#align order.pred_bot Order.pred_botₓ'. -/
 @[simp]
 theorem pred_bot : pred (⊥ : α) = ⊥ :=
   isMin_bot.pred_eq
 #align order.pred_bot Order.pred_bot
 
-/- warning: order.le_pred_iff_eq_bot -> Order.le_pred_iff_eq_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-Case conversion may be inaccurate. Consider using '#align order.le_pred_iff_eq_bot Order.le_pred_iff_eq_botₓ'. -/
 @[simp]
 theorem le_pred_iff_eq_bot : a ≤ pred a ↔ a = ⊥ :=
   @succ_le_iff_eq_top αᵒᵈ _ _ _ _
 #align order.le_pred_iff_eq_bot Order.le_pred_iff_eq_bot
 
-/- warning: order.pred_lt_iff_ne_bot -> Order.pred_lt_iff_ne_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_ne_bot Order.pred_lt_iff_ne_botₓ'. -/
 @[simp]
 theorem pred_lt_iff_ne_bot : pred a < a ↔ a ≠ ⊥ :=
   @lt_succ_iff_ne_top αᵒᵈ _ _ _ _
@@ -1689,45 +897,21 @@ section OrderTop
 
 variable [OrderTop α]
 
-/- warning: order.pred_top_lt_iff -> Order.pred_top_lt_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
-Case conversion may be inaccurate. Consider using '#align order.pred_top_lt_iff Order.pred_top_lt_iffₓ'. -/
 @[simp]
 theorem pred_top_lt_iff [NoMinOrder α] : pred ⊤ < a ↔ a = ⊤ :=
   @lt_succ_bot_iff αᵒᵈ _ _ _ _ _
 #align order.pred_top_lt_iff Order.pred_top_lt_iff
 
-/- warning: order.pred_top_le_iff -> Order.pred_top_le_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Or (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Or (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
-Case conversion may be inaccurate. Consider using '#align order.pred_top_le_iff Order.pred_top_le_iffₓ'. -/
 theorem pred_top_le_iff : pred ⊤ ≤ a ↔ a = ⊤ ∨ a = pred ⊤ :=
   @le_succ_bot_iff αᵒᵈ _ _ _ _
 #align order.pred_top_le_iff Order.pred_top_le_iff
 
 variable [Nontrivial α]
 
-/- warning: order.pred_lt_top -> Order.pred_lt_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-Case conversion may be inaccurate. Consider using '#align order.pred_lt_top Order.pred_lt_topₓ'. -/
 theorem pred_lt_top (a : α) : pred a < ⊤ :=
   (pred_mono le_top).trans_lt <| pred_lt_of_not_isMin not_isMin_top
 #align order.pred_lt_top Order.pred_lt_top
 
-/- warning: order.pred_ne_top -> Order.pred_ne_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
-Case conversion may be inaccurate. Consider using '#align order.pred_ne_top Order.pred_ne_topₓ'. -/
 theorem pred_ne_top (a : α) : pred a ≠ ⊤ :=
   (pred_lt_top a).Ne
 #align order.pred_ne_top Order.pred_ne_top
@@ -1749,12 +933,6 @@ section CompleteLattice
 
 variable [CompleteLattice α] [PredOrder α]
 
-/- warning: order.pred_eq_supr -> Order.pred_eq_iSup is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iSup.{u1, succ u1} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) α (fun (b : α) => iSup.{u1, 0} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iSup.{u1, succ u1} α (CompleteLattice.toSupSet.{u1} α _inst_1) α (fun (b : α) => iSup.{u1, 0} α (CompleteLattice.toSupSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
-Case conversion may be inaccurate. Consider using '#align order.pred_eq_supr Order.pred_eq_iSupₓ'. -/
 theorem pred_eq_iSup (a : α) : pred a = ⨆ (b) (h : b < a), b :=
   by
   refine' le_antisymm _ (iSup_le fun b => iSup_le le_pred_of_lt)
@@ -1773,56 +951,26 @@ section SuccPredOrder
 
 variable [PartialOrder α] [SuccOrder α] [PredOrder α] {a b : α}
 
-/- warning: order.succ_pred_of_not_is_min -> Order.succ_pred_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a)
-Case conversion may be inaccurate. Consider using '#align order.succ_pred_of_not_is_min Order.succ_pred_of_not_isMinₓ'. -/
 @[simp]
 theorem succ_pred_of_not_isMin (h : ¬IsMin a) : succ (pred a) = a :=
   (pred_covby_of_not_isMin h).succ_eq
 #align order.succ_pred_of_not_is_min Order.succ_pred_of_not_isMin
 
-/- warning: order.pred_succ_of_not_is_max -> Order.pred_succ_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a)
-Case conversion may be inaccurate. Consider using '#align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMaxₓ'. -/
 @[simp]
 theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a :=
   (covby_succ_of_not_isMax h).pred_eq
 #align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMax
 
-/- warning: order.succ_pred -> Order.succ_pred is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a
-Case conversion may be inaccurate. Consider using '#align order.succ_pred Order.succ_predₓ'. -/
 @[simp]
 theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a :=
   (pred_covby _).succ_eq
 #align order.succ_pred Order.succ_pred
 
-/- warning: order.pred_succ -> Order.pred_succ is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a
-Case conversion may be inaccurate. Consider using '#align order.pred_succ Order.pred_succₓ'. -/
 @[simp]
 theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
   (covby_succ _).pred_eq
 #align order.pred_succ Order.pred_succ
 
-/- warning: order.pred_succ_iterate_of_not_is_max -> Order.pred_succ_iterate_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n i)) i)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n i)) i)
-Case conversion may be inaccurate. Consider using '#align order.pred_succ_iterate_of_not_is_max Order.pred_succ_iterate_of_not_isMaxₓ'. -/
 theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^[n - 1]) i)) :
     (pred^[n]) ((succ^[n]) i) = i := by
   induction' n with n hn
@@ -1846,12 +994,6 @@ theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^
   exact hn h_not_max
 #align order.pred_succ_iterate_of_not_is_max Order.pred_succ_iterate_of_not_isMax
 
-/- warning: order.succ_pred_iterate_of_not_is_min -> Order.succ_pred_iterate_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n i)) i)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n i)) i)
-Case conversion may be inaccurate. Consider using '#align order.succ_pred_iterate_of_not_is_min Order.succ_pred_iterate_of_not_isMinₓ'. -/
 theorem succ_pred_iterate_of_not_isMin (i : α) (n : ℕ) (hin : ¬IsMin ((pred^[n - 1]) i)) :
     (succ^[n]) ((pred^[n]) i) = i :=
   @pred_succ_iterate_of_not_isMax αᵒᵈ _ _ _ i n hin
@@ -1930,23 +1072,11 @@ instance : SuccOrder (WithTop α)
       exact le_top
     · exact le_of_lt_succ (some_lt_some.1 h)
 
-/- warning: with_top.succ_coe_top -> WithTop.succ_coe_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.succOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.instSuccOrderWithTopPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))
-Case conversion may be inaccurate. Consider using '#align with_top.succ_coe_top WithTop.succ_coe_topₓ'. -/
 @[simp]
 theorem succ_coe_top : succ ↑(⊤ : α) = (⊤ : WithTop α) :=
   dif_pos rfl
 #align with_top.succ_coe_top WithTop.succ_coe_top
 
-/- warning: with_top.succ_coe_of_ne_top -> WithTop.succ_coe_of_ne_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.succOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.instSuccOrderWithTopPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithTop.some.{u1} α a)) (WithTop.some.{u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
-Case conversion may be inaccurate. Consider using '#align with_top.succ_coe_of_ne_top WithTop.succ_coe_of_ne_topₓ'. -/
 theorem succ_coe_of_ne_top {a : α} (h : a ≠ ⊤) : succ (↑a : WithTop α) = ↑(succ a) :=
   dif_neg h
 #align with_top.succ_coe_of_ne_top WithTop.succ_coe_of_ne_top
@@ -1984,31 +1114,16 @@ instance : PredOrder (WithTop α)
     · exact (not_top_lt <| some_lt_some.1 h).elim
     · exact some_le_some.2 (le_of_pred_lt <| some_lt_some.1 h)
 
-/- warning: with_top.pred_top -> WithTop.pred_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align with_top.pred_top WithTop.pred_topₓ'. -/
 @[simp]
 theorem pred_top : pred (⊤ : WithTop α) = ↑(⊤ : α) :=
   rfl
 #align with_top.pred_top WithTop.pred_top
 
-/- warning: with_top.pred_coe -> WithTop.pred_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) (WithTop.some.{u1} α a)) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))
-Case conversion may be inaccurate. Consider using '#align with_top.pred_coe WithTop.pred_coeₓ'. -/
 @[simp]
 theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
   rfl
 #align with_top.pred_coe WithTop.pred_coe
 
-/- warning: with_top.pred_untop -> WithTop.pred_untop is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align with_top.pred_untop WithTop.pred_untopₓ'. -/
 @[simp]
 theorem pred_untop :
     ∀ (a : WithTop α) (ha : a ≠ ⊤),
@@ -2026,12 +1141,6 @@ section Succ
 
 variable [Preorder α] [NoMaxOrder α] [SuccOrder α]
 
-/- warning: with_top.succ_order_of_no_max_order -> WithTop.succOrderOfNoMaxOrder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], SuccOrder.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], SuccOrder.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align with_top.succ_order_of_no_max_order WithTop.succOrderOfNoMaxOrderₓ'. -/
 instance succOrderOfNoMaxOrder : SuccOrder (WithTop α)
     where
   succ a :=
@@ -2060,12 +1169,6 @@ instance succOrderOfNoMaxOrder : SuccOrder (WithTop α)
     · exact some_le_some.2 (le_of_lt_succ <| some_lt_some.1 h)
 #align with_top.succ_order_of_no_max_order WithTop.succOrderOfNoMaxOrder
 
-/- warning: with_top.succ_coe -> WithTop.succ_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.succOrderOfNoMaxOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.succOrderOfNoMaxOrder.{u1} α _inst_1 _inst_2 _inst_3) (WithTop.some.{u1} α a)) (WithTop.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))
-Case conversion may be inaccurate. Consider using '#align with_top.succ_coe WithTop.succ_coeₓ'. -/
 @[simp]
 theorem succ_coe (a : α) : succ (↑a : WithTop α) = ↑(succ a) :=
   rfl
@@ -2126,31 +1229,16 @@ instance : SuccOrder (WithBot α)
     · exact (not_lt_bot <| some_lt_some.1 h).elim
     · exact some_le_some.2 (le_of_lt_succ <| some_lt_some.1 h)
 
-/- warning: with_bot.succ_bot -> WithBot.succ_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align with_bot.succ_bot WithBot.succ_botₓ'. -/
 @[simp]
 theorem succ_bot : succ (⊥ : WithBot α) = ↑(⊥ : α) :=
   rfl
 #align with_bot.succ_bot WithBot.succ_bot
 
-/- warning: with_bot.succ_coe -> WithBot.succ_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) (WithBot.some.{u1} α a)) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))
-Case conversion may be inaccurate. Consider using '#align with_bot.succ_coe WithBot.succ_coeₓ'. -/
 @[simp]
 theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
   rfl
 #align with_bot.succ_coe WithBot.succ_coe
 
-/- warning: with_bot.succ_unbot -> WithBot.succ_unbot is a dubious translation:
-<too large>
-Case conversion may be inaccurate. Consider using '#align with_bot.succ_unbot WithBot.succ_unbotₓ'. -/
 @[simp]
 theorem succ_unbot :
     ∀ (a : WithBot α) (ha : a ≠ ⊥),
@@ -2209,23 +1297,11 @@ instance : PredOrder (WithBot α)
       exact bot_le
     · exact le_of_pred_lt (some_lt_some.1 h)
 
-/- warning: with_bot.pred_coe_bot -> WithBot.pred_coe_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.predOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.instPredOrderWithBotPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))
-Case conversion may be inaccurate. Consider using '#align with_bot.pred_coe_bot WithBot.pred_coe_botₓ'. -/
 @[simp]
 theorem pred_coe_bot : pred ↑(⊥ : α) = (⊥ : WithBot α) :=
   dif_pos rfl
 #align with_bot.pred_coe_bot WithBot.pred_coe_bot
 
-/- warning: with_bot.pred_coe_of_ne_bot -> WithBot.pred_coe_of_ne_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.predOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.instPredOrderWithBotPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithBot.some.{u1} α a)) (WithBot.some.{u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
-Case conversion may be inaccurate. Consider using '#align with_bot.pred_coe_of_ne_bot WithBot.pred_coe_of_ne_botₓ'. -/
 theorem pred_coe_of_ne_bot {a : α} (h : a ≠ ⊥) : pred (↑a : WithBot α) = ↑(pred a) :=
   dif_neg h
 #align with_bot.pred_coe_of_ne_bot WithBot.pred_coe_of_ne_bot
@@ -2254,12 +1330,6 @@ section Pred
 
 variable [Preorder α] [NoMinOrder α] [PredOrder α]
 
-/- warning: with_bot.pred_order_of_no_min_order -> WithBot.predOrderOfNoMinOrder is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], PredOrder.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], PredOrder.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)
-Case conversion may be inaccurate. Consider using '#align with_bot.pred_order_of_no_min_order WithBot.predOrderOfNoMinOrderₓ'. -/
 instance predOrderOfNoMinOrder : PredOrder (WithBot α)
     where
   pred a :=
@@ -2288,12 +1358,6 @@ instance predOrderOfNoMinOrder : PredOrder (WithBot α)
     · exact some_le_some.2 (le_of_pred_lt <| some_lt_some.1 h)
 #align with_bot.pred_order_of_no_min_order WithBot.predOrderOfNoMinOrder
 
-/- warning: with_bot.pred_coe -> WithBot.pred_coe is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.predOrderOfNoMinOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.predOrderOfNoMinOrder.{u1} α _inst_1 _inst_2 _inst_3) (WithBot.some.{u1} α a)) (WithBot.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))
-Case conversion may be inaccurate. Consider using '#align with_bot.pred_coe WithBot.pred_coeₓ'. -/
 @[simp]
 theorem pred_coe (a : α) : pred (↑a : WithBot α) = ↑(pred a) :=
   rfl
@@ -2337,22 +1401,10 @@ variable [SuccOrder α] [IsSuccArchimedean α] {a b : α}
 instance : IsPredArchimedean αᵒᵈ :=
   ⟨fun a b h => by convert exists_succ_iterate_of_le h.of_dual⟩
 
-/- warning: has_le.le.exists_succ_iterate -> LE.le.exists_succ_iterate is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b))
-Case conversion may be inaccurate. Consider using '#align has_le.le.exists_succ_iterate LE.le.exists_succ_iterateₓ'. -/
 theorem LE.le.exists_succ_iterate (h : a ≤ b) : ∃ n, (succ^[n]) a = b :=
   exists_succ_iterate_of_le h
 #align has_le.le.exists_succ_iterate LE.le.exists_succ_iterate
 
-/- warning: exists_succ_iterate_iff_le -> exists_succ_iterate_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align exists_succ_iterate_iff_le exists_succ_iterate_iff_leₓ'. -/
 theorem exists_succ_iterate_iff_le : (∃ n, (succ^[n]) a = b) ↔ a ≤ b :=
   by
   refine' ⟨_, exists_succ_iterate_of_le⟩
@@ -2360,12 +1412,6 @@ theorem exists_succ_iterate_iff_le : (∃ n, (succ^[n]) a = b) ↔ a ≤ b :=
   exact id_le_iterate_of_id_le le_succ n a
 #align exists_succ_iterate_iff_le exists_succ_iterate_iff_le
 
-/- warning: succ.rec -> Succ.rec is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) m n) -> (P n) -> (P (Order.succ.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) m n) -> (P n))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) m n) -> (P n) -> (P (Order.succ.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) m n) -> (P n))
-Case conversion may be inaccurate. Consider using '#align succ.rec Succ.recₓ'. -/
 /-- Induction principle on a type with a `succ_order` for all elements above a given element `m`. -/
 @[elab_as_elim]
 theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n → P n → P (succ n)) ⦃n : α⦄
@@ -2376,12 +1422,6 @@ theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n →
   · rw [Function.iterate_succ_apply']; exact h1 _ (id_le_iterate_of_id_le le_succ n m) ih
 #align succ.rec Succ.rec
 
-/- warning: succ.rec_iff -> Succ.rec_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.succ.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.succ.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
-Case conversion may be inaccurate. Consider using '#align succ.rec_iff Succ.rec_iffₓ'. -/
 theorem Succ.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (succ a)) {a b : α} (h : a ≤ b) :
     p a ↔ p b := by
   obtain ⟨n, rfl⟩ := h.exists_succ_iterate
@@ -2397,32 +1437,14 @@ variable [PredOrder α] [IsPredArchimedean α] {a b : α}
 instance : IsSuccArchimedean αᵒᵈ :=
   ⟨fun a b h => by convert exists_pred_iterate_of_le h.of_dual⟩
 
-/- warning: has_le.le.exists_pred_iterate -> LE.le.exists_pred_iterate is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a))
-Case conversion may be inaccurate. Consider using '#align has_le.le.exists_pred_iterate LE.le.exists_pred_iterateₓ'. -/
 theorem LE.le.exists_pred_iterate (h : a ≤ b) : ∃ n, (pred^[n]) b = a :=
   exists_pred_iterate_of_le h
 #align has_le.le.exists_pred_iterate LE.le.exists_pred_iterate
 
-/- warning: exists_pred_iterate_iff_le -> exists_pred_iterate_iff_le is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
-Case conversion may be inaccurate. Consider using '#align exists_pred_iterate_iff_le exists_pred_iterate_iff_leₓ'. -/
 theorem exists_pred_iterate_iff_le : (∃ n, (pred^[n]) b = a) ↔ a ≤ b :=
   @exists_succ_iterate_iff_le αᵒᵈ _ _ _ _ _
 #align exists_pred_iterate_iff_le exists_pred_iterate_iff_le
 
-/- warning: pred.rec -> Pred.rec is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) n m) -> (P n) -> (P (Order.pred.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) n m) -> (P n))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) n m) -> (P n) -> (P (Order.pred.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) n m) -> (P n))
-Case conversion may be inaccurate. Consider using '#align pred.rec Pred.recₓ'. -/
 /-- Induction principle on a type with a `pred_order` for all elements below a given element `m`. -/
 @[elab_as_elim]
 theorem Pred.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, n ≤ m → P n → P (pred n)) ⦃n : α⦄
@@ -2430,12 +1452,6 @@ theorem Pred.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, n ≤ m →
   @Succ.rec αᵒᵈ _ _ _ _ _ h0 h1 _ hmn
 #align pred.rec Pred.rec
 
-/- warning: pred.rec_iff -> Pred.rec_iff is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.pred.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.pred.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
-Case conversion may be inaccurate. Consider using '#align pred.rec_iff Pred.rec_iffₓ'. -/
 theorem Pred.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) {a b : α} (h : a ≤ b) :
     p a ↔ p b :=
   (@Succ.rec_iff αᵒᵈ _ _ _ _ hsucc _ _ h).symm
@@ -2491,12 +1507,6 @@ section IsWellOrder
 
 variable [LinearOrder α]
 
-/- warning: is_well_order.to_is_pred_archimedean -> IsWellOrder.toIsPredArchimedean is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))], IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) _inst_2
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.SuccPred.Basic._hyg.11728 : α) (x._@.Mathlib.Order.SuccPred.Basic._hyg.11730 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Order.SuccPred.Basic._hyg.11728 x._@.Mathlib.Order.SuccPred.Basic._hyg.11730)] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))], IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2
-Case conversion may be inaccurate. Consider using '#align is_well_order.to_is_pred_archimedean IsWellOrder.toIsPredArchimedeanₓ'. -/
 instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (· < ·)]
     [PredOrder α] : IsPredArchimedean α :=
   ⟨fun a => by
@@ -2511,12 +1521,6 @@ instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (
     rw [iterate_add_apply, iterate_one, hk]⟩
 #align is_well_order.to_is_pred_archimedean IsWellOrder.toIsPredArchimedean
 
-/- warning: is_well_order.to_is_succ_archimedean -> IsWellOrder.toIsSuccArchimedean is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))], IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) _inst_2
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.SuccPred.Basic._hyg.11899 : α) (x._@.Mathlib.Order.SuccPred.Basic._hyg.11901 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Order.SuccPred.Basic._hyg.11899 x._@.Mathlib.Order.SuccPred.Basic._hyg.11901)] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))], IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2
-Case conversion may be inaccurate. Consider using '#align is_well_order.to_is_succ_archimedean IsWellOrder.toIsSuccArchimedeanₓ'. -/
 instance (priority := 100) IsWellOrder.toIsSuccArchimedean [h : IsWellOrder α (· > ·)]
     [SuccOrder α] : IsSuccArchimedean α := by convert@OrderDual.isSuccArchimedean αᵒᵈ _ _ _
 #align is_well_order.to_is_succ_archimedean IsWellOrder.toIsSuccArchimedean
@@ -2527,12 +1531,6 @@ section OrderBot
 
 variable [Preorder α] [OrderBot α] [SuccOrder α] [IsSuccArchimedean α]
 
-/- warning: succ.rec_bot -> Succ.rec_bot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] [_inst_4 : IsSuccArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.succ.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] [_inst_4 : IsSuccArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.succ.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
-Case conversion may be inaccurate. Consider using '#align succ.rec_bot Succ.rec_botₓ'. -/
 theorem Succ.rec_bot (p : α → Prop) (hbot : p ⊥) (hsucc : ∀ a, p a → p (succ a)) (a : α) : p a :=
   Succ.rec hbot (fun x _ h => hsucc x h) (bot_le : ⊥ ≤ a)
 #align succ.rec_bot Succ.rec_bot
@@ -2543,12 +1541,6 @@ section OrderTop
 
 variable [Preorder α] [OrderTop α] [PredOrder α] [IsPredArchimedean α]
 
-/- warning: pred.rec_top -> Pred.rec_top is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] [_inst_4 : IsPredArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.pred.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] [_inst_4 : IsPredArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.pred.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
-Case conversion may be inaccurate. Consider using '#align pred.rec_top Pred.rec_topₓ'. -/
 theorem Pred.rec_top (p : α → Prop) (htop : p ⊤) (hpred : ∀ a, p a → p (pred a)) (a : α) : p a :=
   Pred.rec htop (fun x _ h => hpred x h) (le_top : a ≤ ⊤)
 #align pred.rec_top Pred.rec_top

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

@@ -873,9 +873,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
 Case conversion may be inaccurate. Consider using '#align order.succ_eq_iff_covby Order.succ_eq_iff_covbyₓ'. -/
 theorem succ_eq_iff_covby : succ a = b ↔ a ⋖ b :=
-  ⟨by
-    rintro rfl
-    exact covby_succ _, Covby.succ_eq⟩
+  ⟨by rintro rfl; exact covby_succ _, Covby.succ_eq⟩
 #align order.succ_eq_iff_covby Order.succ_eq_iff_covby
 
 /- warning: order.Iio_succ_eq_insert -> Order.Iio_succ_eq_insert is a dubious translation:
@@ -1613,9 +1611,7 @@ but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
 Case conversion may be inaccurate. Consider using '#align order.pred_eq_iff_covby Order.pred_eq_iff_covbyₓ'. -/
 theorem pred_eq_iff_covby : pred b = a ↔ a ⋖ b :=
-  ⟨by
-    rintro rfl
-    exact pred_covby _, Covby.pred_eq⟩
+  ⟨by rintro rfl; exact pred_covby _, Covby.pred_eq⟩
 #align order.pred_eq_iff_covby Order.pred_eq_iff_covby
 
 /- warning: order.Ioi_pred_eq_insert -> Order.Ioi_pred_eq_insert is a dubious translation:
@@ -2377,8 +2373,7 @@ theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n →
   obtain ⟨n, rfl⟩ := hmn.exists_succ_iterate; clear hmn
   induction' n with n ih
   · exact h0
-  · rw [Function.iterate_succ_apply']
-    exact h1 _ (id_le_iterate_of_id_le le_succ n m) ih
+  · rw [Function.iterate_succ_apply']; exact h1 _ (id_le_iterate_of_id_le le_succ n m) ih
 #align succ.rec Succ.rec
 
 /- warning: succ.rec_iff -> Succ.rec_iff is a dubious translation:

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

@@ -2011,10 +2011,7 @@ theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
 #align with_top.pred_coe WithTop.pred_coe
 
 /- warning: with_top.pred_untop -> WithTop.pred_untop is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (WithTop.pred_top.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (WithTop.pred_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Order.pred.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) not_false_eq_true)) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))) not_false_eq_true)) a ha))
+<too large>
 Case conversion may be inaccurate. Consider using '#align with_top.pred_untop WithTop.pred_untopₓ'. -/
 @[simp]
 theorem pred_untop :
@@ -2156,10 +2153,7 @@ theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
 #align with_bot.succ_coe WithBot.succ_coe
 
 /- warning: with_bot.succ_unbot -> WithBot.succ_unbot is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (WithBot.succ_bot.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (WithBot.succ_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Order.succ.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) not_false_eq_true)) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))) not_false_eq_true)) a ha))
+<too large>
 Case conversion may be inaccurate. Consider using '#align with_bot.succ_unbot WithBot.succ_unbotₓ'. -/
 @[simp]
 theorem succ_unbot :

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

@@ -108,7 +108,12 @@ section Preorder
 
 variable [Preorder α]
 
-#print SuccOrder.ofSuccLeIffOfLeLtSucc /-
+/- warning: succ_order.of_succ_le_iff_of_le_lt_succ -> SuccOrder.ofSuccLeIffOfLeLtSucc is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (succ a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (succ b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (SuccOrder.{u1} α _inst_1)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (succ a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (succ b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)) -> (SuccOrder.{u1} α _inst_1)
+Case conversion may be inaccurate. Consider using '#align succ_order.of_succ_le_iff_of_le_lt_succ SuccOrder.ofSuccLeIffOfLeLtSuccₓ'. -/
 /-- A constructor for `succ_order α` usable when `α` has no maximal element. -/
 def SuccOrder.ofSuccLeIffOfLeLtSucc (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b)
     (hle_of_lt_succ : ∀ {a b}, a < succ b → a ≤ b) : SuccOrder α :=
@@ -118,9 +123,13 @@ def SuccOrder.ofSuccLeIffOfLeLtSucc (succ : α → α) (hsucc_le_iff : ∀ {a b}
     succ_le_of_lt := fun a b => hsucc_le_iff.2
     le_of_lt_succ := fun a b => hle_of_lt_succ }
 #align succ_order.of_succ_le_iff_of_le_lt_succ SuccOrder.ofSuccLeIffOfLeLtSucc
--/
 
-#print PredOrder.ofLePredIffOfPredLePred /-
+/- warning: pred_order.of_le_pred_iff_of_pred_le_pred -> PredOrder.ofLePredIffOfPredLePred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (pred b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (pred a) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)) -> (PredOrder.{u1} α _inst_1)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (pred b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)) -> (forall {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (pred a) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)) -> (PredOrder.{u1} α _inst_1)
+Case conversion may be inaccurate. Consider using '#align pred_order.of_le_pred_iff_of_pred_le_pred PredOrder.ofLePredIffOfPredLePredₓ'. -/
 /-- A constructor for `pred_order α` usable when `α` has no minimal element. -/
 def PredOrder.ofLePredIffOfPredLePred (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b)
     (hle_of_pred_lt : ∀ {a b}, pred a < b → a ≤ b) : PredOrder α :=
@@ -130,7 +139,6 @@ def PredOrder.ofLePredIffOfPredLePred (pred : α → α) (hle_pred_iff : ∀ {a
     le_pred_of_lt := fun a b => hle_pred_iff.2
     le_of_pred_lt := fun a b => hle_of_pred_lt }
 #align pred_order.of_le_pred_iff_of_pred_le_pred PredOrder.ofLePredIffOfPredLePred
--/
 
 end Preorder
 
@@ -138,7 +146,12 @@ section LinearOrder
 
 variable [LinearOrder α]
 
-#print SuccOrder.ofCore /-
+/- warning: succ_order.of_core -> SuccOrder.ofCore is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a)) -> (forall (b : α), Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (succ a) b))) -> (forall (a : α), (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a) -> (Eq.{succ u1} α (succ a) a)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a)) -> (forall (b : α), Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (succ a) b))) -> (forall (a : α), (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a) -> (Eq.{succ u1} α (succ a) a)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align succ_order.of_core SuccOrder.ofCoreₓ'. -/
 /-- A constructor for `succ_order α` for `α` a linear order. -/
 @[simps]
 def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a < b ↔ succ a ≤ b)
@@ -151,9 +164,13 @@ def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a <
       by_cases (fun h => hm b h ▸ hab.le) fun h => by simpa [hab] using (hn h a).Not
     max_of_succ_le := fun a => not_imp_not.mp fun h => by simpa using (hn h a).Not }
 #align succ_order.of_core SuccOrder.ofCore
--/
 
-#print PredOrder.ofCore /-
+/- warning: pred_order.of_core -> PredOrder.ofCore is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_2 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a)) -> (forall (b : α), Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) b (pred a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) b a))) -> (forall (a : α), (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2))))) a) -> (Eq.{succ u1} α (pred a) a)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_2)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_2 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a)) -> (forall (b : α), Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) b (pred a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) b a))) -> (forall (a : α), (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2)))))) a) -> (Eq.{succ u1} α (pred a) a)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_2))))))
+Case conversion may be inaccurate. Consider using '#align pred_order.of_core PredOrder.ofCoreₓ'. -/
 /-- A constructor for `pred_order α` for `α` a linear order. -/
 @[simps]
 def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
@@ -167,9 +184,13 @@ def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
       by_cases (fun h => hm a h ▸ hab.le) fun h => by simpa [hab] using (hn h b).Not
     min_of_le_pred := fun a => not_imp_not.mp fun h => by simpa using (hn h a).Not }
 #align pred_order.of_core PredOrder.ofCore
--/
 
-#print SuccOrder.ofSuccLeIff /-
+/- warning: succ_order.of_succ_le_iff -> SuccOrder.ofSuccLeIff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) (succ a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (succ : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) (succ a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)) -> (SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align succ_order.of_succ_le_iff SuccOrder.ofSuccLeIffₓ'. -/
 /-- A constructor for `succ_order α` usable when `α` is a linear order with no maximal element. -/
 def SuccOrder.ofSuccLeIff (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b) :
     SuccOrder α :=
@@ -179,9 +200,13 @@ def SuccOrder.ofSuccLeIff (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a 
     succ_le_of_lt := fun a b => hsucc_le_iff.2
     le_of_lt_succ := fun a b h => le_of_not_lt ((not_congr hsucc_le_iff).1 h.not_le) }
 #align succ_order.of_succ_le_iff SuccOrder.ofSuccLeIff
--/
 
-#print PredOrder.ofLePredIff /-
+/- warning: pred_order.of_le_pred_iff -> PredOrder.ofLePredIff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a (pred b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))) a b)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] (pred : α -> α), (forall {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a (pred b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) a b)) -> (PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))))
+Case conversion may be inaccurate. Consider using '#align pred_order.of_le_pred_iff PredOrder.ofLePredIffₓ'. -/
 /-- A constructor for `pred_order α` usable when `α` is a linear order with no minimal element. -/
 def PredOrder.ofLePredIff (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b) :
     PredOrder α :=
@@ -191,7 +216,6 @@ def PredOrder.ofLePredIff (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pr
     le_pred_of_lt := fun a b => hle_pred_iff.2
     le_of_pred_lt := fun a b h => le_of_not_lt ((not_congr hle_pred_iff).1 h.not_le) }
 #align pred_order.of_le_pred_iff PredOrder.ofLePredIff
--/
 
 end LinearOrder
 
@@ -212,44 +236,74 @@ def succ : α → α :=
 #align order.succ Order.succ
 -/
 
-#print Order.le_succ /-
+/- warning: order.le_succ -> Order.le_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
+Case conversion may be inaccurate. Consider using '#align order.le_succ Order.le_succₓ'. -/
 theorem le_succ : ∀ a : α, a ≤ succ a :=
   SuccOrder.le_succ
 #align order.le_succ Order.le_succ
--/
 
-#print Order.max_of_succ_le /-
+/- warning: order.max_of_succ_le -> Order.max_of_succ_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.max_of_succ_le Order.max_of_succ_leₓ'. -/
 theorem max_of_succ_le {a : α} : succ a ≤ a → IsMax a :=
   SuccOrder.max_of_succ_le
 #align order.max_of_succ_le Order.max_of_succ_le
--/
 
-#print Order.succ_le_of_lt /-
+/- warning: order.succ_le_of_lt -> Order.succ_le_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b)
+Case conversion may be inaccurate. Consider using '#align order.succ_le_of_lt Order.succ_le_of_ltₓ'. -/
 theorem succ_le_of_lt {a b : α} : a < b → succ a ≤ b :=
   SuccOrder.succ_le_of_lt
 #align order.succ_le_of_lt Order.succ_le_of_lt
--/
 
-#print Order.le_of_lt_succ /-
+/- warning: order.le_of_lt_succ -> Order.le_of_lt_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.le_of_lt_succ Order.le_of_lt_succₓ'. -/
 theorem le_of_lt_succ {a b : α} : a < succ b → a ≤ b :=
   SuccOrder.le_of_lt_succ
 #align order.le_of_lt_succ Order.le_of_lt_succ
--/
 
-#print Order.succ_le_iff_isMax /-
+/- warning: order.succ_le_iff_is_max -> Order.succ_le_iff_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) a) (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.succ_le_iff_is_max Order.succ_le_iff_isMaxₓ'. -/
 @[simp]
 theorem succ_le_iff_isMax : succ a ≤ a ↔ IsMax a :=
   ⟨max_of_succ_le, fun h => h <| le_succ _⟩
 #align order.succ_le_iff_is_max Order.succ_le_iff_isMax
--/
 
-#print Order.lt_succ_iff_not_isMax /-
+/- warning: order.lt_succ_iff_not_is_max -> Order.lt_succ_iff_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 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 : SuccOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)) (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_not_is_max Order.lt_succ_iff_not_isMaxₓ'. -/
 @[simp]
 theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a :=
   ⟨not_isMax_of_lt, fun ha => (le_succ a).lt_of_not_le fun h => ha <| max_of_succ_le h⟩
 #align order.lt_succ_iff_not_is_max Order.lt_succ_iff_not_isMax
--/
 
+/- warning: order.lt_succ_of_not_is_max -> Order.lt_succ_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMaxₓ'. -/
 alias lt_succ_iff_not_is_max ↔ _ lt_succ_of_not_is_max
 #align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMax
 
@@ -259,37 +313,62 @@ theorem wcovby_succ (a : α) : a ⩿ succ a :=
 #align order.wcovby_succ Order.wcovby_succ
 -/
 
-#print Order.covby_succ_of_not_isMax /-
+/- warning: order.covby_succ_of_not_is_max -> Order.covby_succ_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align order.covby_succ_of_not_is_max Order.covby_succ_of_not_isMaxₓ'. -/
 theorem covby_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a :=
   (wcovby_succ a).covby_of_lt <| lt_succ_of_not_isMax h
 #align order.covby_succ_of_not_is_max Order.covby_succ_of_not_isMax
--/
 
-#print Order.lt_succ_iff_of_not_isMax /-
+/- warning: order.lt_succ_iff_of_not_is_max -> Order.lt_succ_iff_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b (Order.succ.{u1} α _inst_1 _inst_2 a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b (Order.succ.{u1} α _inst_1 _inst_2 a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_of_not_is_max Order.lt_succ_iff_of_not_isMaxₓ'. -/
 theorem lt_succ_iff_of_not_isMax (ha : ¬IsMax a) : b < succ a ↔ b ≤ a :=
   ⟨le_of_lt_succ, fun h => h.trans_lt <| lt_succ_of_not_isMax ha⟩
 #align order.lt_succ_iff_of_not_is_max Order.lt_succ_iff_of_not_isMax
--/
 
-#print Order.succ_le_iff_of_not_isMax /-
+/- warning: order.succ_le_iff_of_not_is_max -> Order.succ_le_iff_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMaxₓ'. -/
 theorem succ_le_iff_of_not_isMax (ha : ¬IsMax a) : succ a ≤ b ↔ a < b :=
   ⟨(lt_succ_of_not_isMax ha).trans_le, succ_le_of_lt⟩
 #align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMax
--/
 
-#print Order.succ_lt_succ_iff_of_not_isMax /-
+/- warning: order.succ_lt_succ_iff_of_not_is_max -> Order.succ_lt_succ_iff_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align order.succ_lt_succ_iff_of_not_is_max Order.succ_lt_succ_iff_of_not_isMaxₓ'. -/
 theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a < succ b ↔ a < b :=
   by rw [lt_succ_iff_of_not_is_max hb, succ_le_iff_of_not_is_max ha]
 #align order.succ_lt_succ_iff_of_not_is_max Order.succ_lt_succ_iff_of_not_isMax
--/
 
-#print Order.succ_le_succ_iff_of_not_isMax /-
+/- warning: order.succ_le_succ_iff_of_not_is_max -> Order.succ_le_succ_iff_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align order.succ_le_succ_iff_of_not_is_max Order.succ_le_succ_iff_of_not_isMaxₓ'. -/
 theorem succ_le_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a ≤ succ b ↔ a ≤ b :=
   by rw [succ_le_iff_of_not_is_max ha, lt_succ_iff_of_not_is_max hb]
 #align order.succ_le_succ_iff_of_not_is_max Order.succ_le_succ_iff_of_not_isMax
--/
 
-#print Order.succ_le_succ /-
+/- warning: order.succ_le_succ -> Order.succ_le_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.succ_le_succ Order.succ_le_succₓ'. -/
 @[simp, mono]
 theorem succ_le_succ (h : a ≤ b) : succ a ≤ succ b :=
   by
@@ -299,22 +378,30 @@ theorem succ_le_succ (h : a ≤ b) : succ a ≤ succ b :=
     · exact succ_le_of_lt ((h.lt_of_not_le hba).trans_le <| le_succ b)
   · rwa [succ_le_iff_of_not_is_max fun ha => hb <| ha.mono h, lt_succ_iff_of_not_is_max hb]
 #align order.succ_le_succ Order.succ_le_succ
--/
 
 #print Order.succ_mono /-
 theorem succ_mono : Monotone (succ : α → α) := fun a b => succ_le_succ
 #align order.succ_mono Order.succ_mono
 -/
 
-#print Order.le_succ_iterate /-
+/- warning: order.le_succ_iterate -> Order.le_succ_iterate is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) x (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) k x)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) x (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) k x)
+Case conversion may be inaccurate. Consider using '#align order.le_succ_iterate Order.le_succ_iterateₓ'. -/
 theorem le_succ_iterate (k : ℕ) (x : α) : x ≤ (succ^[k]) x :=
   by
   conv_lhs => rw [(by simp only [Function.iterate_id, id.def] : x = (id^[k]) x)]
   exact Monotone.le_iterate_of_le succ_mono le_succ k x
 #align order.le_succ_iterate Order.le_succ_iterate
--/
 
-#print Order.isMax_iterate_succ_of_eq_of_lt /-
+/- warning: order.is_max_iterate_succ_of_eq_of_lt -> Order.isMax_iterate_succ_of_eq_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat Nat.hasLt n m) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat instLTNat n m) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
+Case conversion may be inaccurate. Consider using '#align order.is_max_iterate_succ_of_eq_of_lt Order.isMax_iterate_succ_of_eq_of_ltₓ'. -/
 theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : (succ^[n]) a = (succ^[m]) a)
     (h_lt : n < m) : IsMax ((succ^[n]) a) :=
   by
@@ -324,9 +411,13 @@ theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : (succ^[n]) a = (succ^
   have h_le : n + 1 ≤ m := Nat.succ_le_of_lt h_lt
   exact Monotone.monotone_iterate_of_le_map succ_mono (le_succ a) h_le
 #align order.is_max_iterate_succ_of_eq_of_lt Order.isMax_iterate_succ_of_eq_of_lt
--/
 
-#print Order.isMax_iterate_succ_of_eq_of_ne /-
+/- warning: order.is_max_iterate_succ_of_eq_of_ne -> Order.isMax_iterate_succ_of_eq_of_ne is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a))
+Case conversion may be inaccurate. Consider using '#align order.is_max_iterate_succ_of_eq_of_ne Order.isMax_iterate_succ_of_eq_of_neₓ'. -/
 theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : (succ^[n]) a = (succ^[m]) a)
     (h_ne : n ≠ m) : IsMax ((succ^[n]) a) :=
   by
@@ -335,137 +426,230 @@ theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : (succ^[n]) a = (succ^
   · rw [h_eq]
     exact is_max_iterate_succ_of_eq_of_lt h_eq.symm (lt_of_le_of_ne h h_ne.symm)
 #align order.is_max_iterate_succ_of_eq_of_ne Order.isMax_iterate_succ_of_eq_of_ne
--/
 
-#print Order.Iio_succ_of_not_isMax /-
+/- warning: order.Iio_succ_of_not_is_max -> Order.Iio_succ_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a))
+Case conversion may be inaccurate. Consider using '#align order.Iio_succ_of_not_is_max Order.Iio_succ_of_not_isMaxₓ'. -/
 theorem Iio_succ_of_not_isMax (ha : ¬IsMax a) : Iio (succ a) = Iic a :=
   Set.ext fun x => lt_succ_iff_of_not_isMax ha
 #align order.Iio_succ_of_not_is_max Order.Iio_succ_of_not_isMax
--/
 
-#print Order.Ici_succ_of_not_isMax /-
+/- warning: order.Ici_succ_of_not_is_max -> Order.Ici_succ_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a))
+Case conversion may be inaccurate. Consider using '#align order.Ici_succ_of_not_is_max Order.Ici_succ_of_not_isMaxₓ'. -/
 theorem Ici_succ_of_not_isMax (ha : ¬IsMax a) : Ici (succ a) = Ioi a :=
   Set.ext fun x => succ_le_iff_of_not_isMax ha
 #align order.Ici_succ_of_not_is_max Order.Ici_succ_of_not_isMax
--/
 
-#print Order.Ico_succ_right_of_not_isMax /-
+/- warning: order.Ico_succ_right_of_not_is_max -> Order.Ico_succ_right_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right_of_not_is_max Order.Ico_succ_right_of_not_isMaxₓ'. -/
 theorem Ico_succ_right_of_not_isMax (hb : ¬IsMax b) : Ico a (succ b) = Icc a b := by
   rw [← Ici_inter_Iio, Iio_succ_of_not_is_max hb, Ici_inter_Iic]
 #align order.Ico_succ_right_of_not_is_max Order.Ico_succ_right_of_not_isMax
--/
 
-#print Order.Ioo_succ_right_of_not_isMax /-
+/- warning: order.Ioo_succ_right_of_not_is_max -> Order.Ioo_succ_right_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right_of_not_is_max Order.Ioo_succ_right_of_not_isMaxₓ'. -/
 theorem Ioo_succ_right_of_not_isMax (hb : ¬IsMax b) : Ioo a (succ b) = Ioc a b := by
   rw [← Ioi_inter_Iio, Iio_succ_of_not_is_max hb, Ioi_inter_Iic]
 #align order.Ioo_succ_right_of_not_is_max Order.Ioo_succ_right_of_not_isMax
--/
 
-#print Order.Icc_succ_left_of_not_isMax /-
+/- warning: order.Icc_succ_left_of_not_is_max -> Order.Icc_succ_left_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Icc_succ_left_of_not_is_max Order.Icc_succ_left_of_not_isMaxₓ'. -/
 theorem Icc_succ_left_of_not_isMax (ha : ¬IsMax a) : Icc (succ a) b = Ioc a b := by
   rw [← Ici_inter_Iic, Ici_succ_of_not_is_max ha, Ioi_inter_Iic]
 #align order.Icc_succ_left_of_not_is_max Order.Icc_succ_left_of_not_isMax
--/
 
-#print Order.Ico_succ_left_of_not_isMax /-
+/- warning: order.Ico_succ_left_of_not_is_max -> Order.Ico_succ_left_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Ico_succ_left_of_not_is_max Order.Ico_succ_left_of_not_isMaxₓ'. -/
 theorem Ico_succ_left_of_not_isMax (ha : ¬IsMax a) : Ico (succ a) b = Ioo a b := by
   rw [← Ici_inter_Iio, Ici_succ_of_not_is_max ha, Ioi_inter_Iio]
 #align order.Ico_succ_left_of_not_is_max Order.Ico_succ_left_of_not_isMax
--/
 
 section NoMaxOrder
 
 variable [NoMaxOrder α]
 
-#print Order.lt_succ /-
+/- warning: order.lt_succ -> Order.lt_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
+Case conversion may be inaccurate. Consider using '#align order.lt_succ Order.lt_succₓ'. -/
 theorem lt_succ (a : α) : a < succ a :=
   lt_succ_of_not_isMax <| not_isMax a
 #align order.lt_succ Order.lt_succ
--/
 
-#print Order.lt_succ_iff /-
+/- warning: order.lt_succ_iff -> Order.lt_succ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff Order.lt_succ_iffₓ'. -/
 @[simp]
 theorem lt_succ_iff : a < succ b ↔ a ≤ b :=
   lt_succ_iff_of_not_isMax <| not_isMax b
 #align order.lt_succ_iff Order.lt_succ_iff
--/
 
-#print Order.succ_le_iff /-
+/- warning: order.succ_le_iff -> Order.succ_le_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.succ_le_iff Order.succ_le_iffₓ'. -/
 @[simp]
 theorem succ_le_iff : succ a ≤ b ↔ a < b :=
   succ_le_iff_of_not_isMax <| not_isMax a
 #align order.succ_le_iff Order.succ_le_iff
--/
 
-#print Order.succ_le_succ_iff /-
+/- warning: order.succ_le_succ_iff -> Order.succ_le_succ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.succ_le_succ_iff Order.succ_le_succ_iffₓ'. -/
 theorem succ_le_succ_iff : succ a ≤ succ b ↔ a ≤ b := by simp
 #align order.succ_le_succ_iff Order.succ_le_succ_iff
--/
 
-#print Order.succ_lt_succ_iff /-
+/- warning: order.succ_lt_succ_iff -> Order.succ_lt_succ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.succ_lt_succ_iff Order.succ_lt_succ_iffₓ'. -/
 theorem succ_lt_succ_iff : succ a < succ b ↔ a < b := by simp
 #align order.succ_lt_succ_iff Order.succ_lt_succ_iff
--/
 
+/- warning: order.le_of_succ_le_succ -> Order.le_of_succ_le_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.le_of_succ_le_succ Order.le_of_succ_le_succₓ'. -/
 alias succ_le_succ_iff ↔ le_of_succ_le_succ _
 #align order.le_of_succ_le_succ Order.le_of_succ_le_succ
 
+/- warning: order.lt_of_succ_lt_succ -> Order.lt_of_succ_lt_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.lt_of_succ_lt_succ Order.lt_of_succ_lt_succₓ'. -/
+/- warning: order.succ_lt_succ -> Order.succ_lt_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a) (Order.succ.{u1} α _inst_1 _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.succ_lt_succ Order.succ_lt_succₓ'. -/
 alias succ_lt_succ_iff ↔ lt_of_succ_lt_succ succ_lt_succ
 #align order.lt_of_succ_lt_succ Order.lt_of_succ_lt_succ
 #align order.succ_lt_succ Order.succ_lt_succ
 
-#print Order.succ_strictMono /-
+/- warning: order.succ_strict_mono -> Order.succ_strictMono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.succ.{u1} α _inst_1 _inst_2)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.succ.{u1} α _inst_1 _inst_2)
+Case conversion may be inaccurate. Consider using '#align order.succ_strict_mono Order.succ_strictMonoₓ'. -/
 theorem succ_strictMono : StrictMono (succ : α → α) := fun a b => succ_lt_succ
 #align order.succ_strict_mono Order.succ_strictMono
--/
 
-#print Order.covby_succ /-
+/- warning: order.covby_succ -> Order.covby_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) a (Order.succ.{u1} α _inst_1 _inst_2 a)
+Case conversion may be inaccurate. Consider using '#align order.covby_succ Order.covby_succₓ'. -/
 theorem covby_succ (a : α) : a ⋖ succ a :=
   covby_succ_of_not_isMax <| not_isMax a
 #align order.covby_succ Order.covby_succ
--/
 
-#print Order.Iio_succ /-
+/- warning: order.Iio_succ -> Order.Iio_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Iic.{u1} α _inst_1 a)
+Case conversion may be inaccurate. Consider using '#align order.Iio_succ Order.Iio_succₓ'. -/
 @[simp]
 theorem Iio_succ (a : α) : Iio (succ a) = Iic a :=
   Iio_succ_of_not_isMax <| not_isMax _
 #align order.Iio_succ Order.Iio_succ
--/
 
-#print Order.Ici_succ /-
+/- warning: order.Ici_succ -> Order.Ici_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ici.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a)) (Set.Ioi.{u1} α _inst_1 a)
+Case conversion may be inaccurate. Consider using '#align order.Ici_succ Order.Ici_succₓ'. -/
 @[simp]
 theorem Ici_succ (a : α) : Ici (succ a) = Ioi a :=
   Ici_succ_of_not_isMax <| not_isMax _
 #align order.Ici_succ Order.Ici_succ
--/
 
-#print Order.Ico_succ_right /-
+/- warning: order.Ico_succ_right -> Order.Ico_succ_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Icc.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right Order.Ico_succ_rightₓ'. -/
 @[simp]
 theorem Ico_succ_right (a b : α) : Ico a (succ b) = Icc a b :=
   Ico_succ_right_of_not_isMax <| not_isMax _
 #align order.Ico_succ_right Order.Ico_succ_right
--/
 
-#print Order.Ioo_succ_right /-
+/- warning: order.Ioo_succ_right -> Order.Ioo_succ_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 a (Order.succ.{u1} α _inst_1 _inst_2 b)) (Set.Ioc.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right Order.Ioo_succ_rightₓ'. -/
 @[simp]
 theorem Ioo_succ_right (a b : α) : Ioo a (succ b) = Ioc a b :=
   Ioo_succ_right_of_not_isMax <| not_isMax _
 #align order.Ioo_succ_right Order.Ioo_succ_right
--/
 
-#print Order.Icc_succ_left /-
+/- warning: order.Icc_succ_left -> Order.Icc_succ_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioc.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Icc_succ_left Order.Icc_succ_leftₓ'. -/
 @[simp]
 theorem Icc_succ_left (a b : α) : Icc (succ a) b = Ioc a b :=
   Icc_succ_left_of_not_isMax <| not_isMax _
 #align order.Icc_succ_left Order.Icc_succ_left
--/
 
-#print Order.Ico_succ_left /-
+/- warning: order.Ico_succ_left -> Order.Ico_succ_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α _inst_1 (Order.succ.{u1} α _inst_1 _inst_2 a) b) (Set.Ioo.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Ico_succ_left Order.Ico_succ_leftₓ'. -/
 @[simp]
 theorem Ico_succ_left (a b : α) : Ico (succ a) b = Ioo a b :=
   Ico_succ_left_of_not_isMax <| not_isMax _
 #align order.Ico_succ_left Order.Ico_succ_left
--/
 
 end NoMaxOrder
 
@@ -475,25 +659,44 @@ section PartialOrder
 
 variable [PartialOrder α] [SuccOrder α] {a b : α}
 
-#print Order.succ_eq_iff_isMax /-
+/- warning: order.succ_eq_iff_is_max -> Order.succ_eq_iff_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.succ_eq_iff_is_max Order.succ_eq_iff_isMaxₓ'. -/
 @[simp]
 theorem succ_eq_iff_isMax : succ a = a ↔ IsMax a :=
   ⟨fun h => max_of_succ_le h.le, fun h => h.eq_of_ge <| le_succ _⟩
 #align order.succ_eq_iff_is_max Order.succ_eq_iff_isMax
--/
 
+/- warning: is_max.succ_eq -> IsMax.succ_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
+Case conversion may be inaccurate. Consider using '#align is_max.succ_eq IsMax.succ_eqₓ'. -/
 alias succ_eq_iff_is_max ↔ _ _root_.is_max.succ_eq
 #align is_max.succ_eq IsMax.succ_eq
 
-#print Order.succ_eq_succ_iff_of_not_isMax /-
+/- warning: order.succ_eq_succ_iff_of_not_is_max -> Order.succ_eq_succ_iff_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b))
+Case conversion may be inaccurate. Consider using '#align order.succ_eq_succ_iff_of_not_is_max Order.succ_eq_succ_iff_of_not_isMaxₓ'. -/
 theorem succ_eq_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a = succ b ↔ a = b :=
   by
   rw [eq_iff_le_not_lt, eq_iff_le_not_lt, succ_le_succ_iff_of_not_is_max ha hb,
     succ_lt_succ_iff_of_not_is_max ha hb]
 #align order.succ_eq_succ_iff_of_not_is_max Order.succ_eq_succ_iff_of_not_isMax
--/
 
-#print Order.le_le_succ_iff /-
+/- warning: order.le_le_succ_iff -> Order.le_le_succ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
+Case conversion may be inaccurate. Consider using '#align order.le_le_succ_iff Order.le_le_succ_iffₓ'. -/
 theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
   by
   refine'
@@ -505,37 +708,52 @@ theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
   · exact ⟨le_rfl, le_succ b⟩
   · exact ⟨le_succ a, le_rfl⟩
 #align order.le_le_succ_iff Order.le_le_succ_iff
--/
 
-#print Covby.succ_eq /-
+/- warning: covby.succ_eq -> Covby.succ_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)
+Case conversion may be inaccurate. Consider using '#align covby.succ_eq Covby.succ_eqₓ'. -/
 theorem Covby.succ_eq (h : a ⋖ b) : succ a = b :=
   (succ_le_of_lt h.lt).eq_of_not_lt fun h' => h.2 (lt_succ_of_not_isMax h.lt.not_isMax) h'
 #align covby.succ_eq Covby.succ_eq
--/
 
-#print Wcovby.le_succ /-
+/- warning: wcovby.le_succ -> Wcovby.le_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align wcovby.le_succ Wcovby.le_succₓ'. -/
 theorem Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.succ_eq.ge
   · exact le_succ _
 #align wcovby.le_succ Wcovby.le_succ
--/
 
-#print Order.le_succ_iff_eq_or_le /-
+/- warning: order.le_succ_iff_eq_or_le -> Order.le_succ_iff_eq_or_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+Case conversion may be inaccurate. Consider using '#align order.le_succ_iff_eq_or_le Order.le_succ_iff_eq_or_leₓ'. -/
 theorem le_succ_iff_eq_or_le : a ≤ succ b ↔ a = succ b ∨ a ≤ b :=
   by
   by_cases hb : IsMax b
   · rw [hb.succ_eq, or_iff_right_of_imp le_of_eq]
   · rw [← lt_succ_iff_of_not_is_max hb, le_iff_eq_or_lt]
 #align order.le_succ_iff_eq_or_le Order.le_succ_iff_eq_or_le
--/
 
-#print Order.lt_succ_iff_eq_or_lt_of_not_isMax /-
+/- warning: order.lt_succ_iff_eq_or_lt_of_not_is_max -> Order.lt_succ_iff_eq_or_lt_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
+Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_eq_or_lt_of_not_is_max Order.lt_succ_iff_eq_or_lt_of_not_isMaxₓ'. -/
 theorem lt_succ_iff_eq_or_lt_of_not_isMax (hb : ¬IsMax b) : a < succ b ↔ a = b ∨ a < b :=
   (lt_succ_iff_of_not_isMax hb).trans le_iff_eq_or_lt
 #align order.lt_succ_iff_eq_or_lt_of_not_is_max Order.lt_succ_iff_eq_or_lt_of_not_isMax
--/
 
 #print Order.Iic_succ /-
 theorem Iic_succ (a : α) : Iic (succ a) = insert (succ a) (Iic a) :=
@@ -543,94 +761,152 @@ theorem Iic_succ (a : α) : Iic (succ a) = insert (succ a) (Iic a) :=
 #align order.Iic_succ Order.Iic_succ
 -/
 
-#print Order.Icc_succ_right /-
+/- warning: order.Icc_succ_right -> Order.Icc_succ_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Icc_succ_right Order.Icc_succ_rightₓ'. -/
 theorem Icc_succ_right (h : a ≤ succ b) : Icc a (succ b) = insert (succ b) (Icc a b) := by
   simp_rw [← Ici_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ici.2 h)]
 #align order.Icc_succ_right Order.Icc_succ_right
--/
 
-#print Order.Ioc_succ_right /-
+/- warning: order.Ioc_succ_right -> Order.Ioc_succ_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ioc_succ_right Order.Ioc_succ_rightₓ'. -/
 theorem Ioc_succ_right (h : a < succ b) : Ioc a (succ b) = insert (succ b) (Ioc a b) := by
   simp_rw [← Ioi_inter_Iic, Iic_succ, inter_insert_of_mem (mem_Ioi.2 h)]
 #align order.Ioc_succ_right Order.Ioc_succ_right
--/
 
-#print Order.Iio_succ_eq_insert_of_not_isMax /-
+/- warning: order.Iio_succ_eq_insert_of_not_is_max -> Order.Iio_succ_eq_insert_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
+Case conversion may be inaccurate. Consider using '#align order.Iio_succ_eq_insert_of_not_is_max Order.Iio_succ_eq_insert_of_not_isMaxₓ'. -/
 theorem Iio_succ_eq_insert_of_not_isMax (h : ¬IsMax a) : Iio (succ a) = insert a (Iio a) :=
   ext fun _ => lt_succ_iff_eq_or_lt_of_not_isMax h
 #align order.Iio_succ_eq_insert_of_not_is_max Order.Iio_succ_eq_insert_of_not_isMax
--/
 
-#print Order.Ico_succ_right_eq_insert_of_not_isMax /-
+/- warning: order.Ico_succ_right_eq_insert_of_not_is_max -> Order.Ico_succ_right_eq_insert_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right_eq_insert_of_not_is_max Order.Ico_succ_right_eq_insert_of_not_isMaxₓ'. -/
 theorem Ico_succ_right_eq_insert_of_not_isMax (h₁ : a ≤ b) (h₂ : ¬IsMax b) :
     Ico a (succ b) = insert b (Ico a b) := by
   simp_rw [← Iio_inter_Ici, Iio_succ_eq_insert_of_not_is_max h₂, insert_inter_of_mem (mem_Ici.2 h₁)]
 #align order.Ico_succ_right_eq_insert_of_not_is_max Order.Ico_succ_right_eq_insert_of_not_isMax
--/
 
-#print Order.Ioo_succ_right_eq_insert_of_not_isMax /-
+/- warning: order.Ioo_succ_right_eq_insert_of_not_is_max -> Order.Ioo_succ_right_eq_insert_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right_eq_insert_of_not_is_max Order.Ioo_succ_right_eq_insert_of_not_isMaxₓ'. -/
 theorem Ioo_succ_right_eq_insert_of_not_isMax (h₁ : a < b) (h₂ : ¬IsMax b) :
     Ioo a (succ b) = insert b (Ioo a b) := by
   simp_rw [← Iio_inter_Ioi, Iio_succ_eq_insert_of_not_is_max h₂, insert_inter_of_mem (mem_Ioi.2 h₁)]
 #align order.Ioo_succ_right_eq_insert_of_not_is_max Order.Ioo_succ_right_eq_insert_of_not_isMax
--/
 
 section NoMaxOrder
 
 variable [NoMaxOrder α]
 
-#print Order.succ_eq_succ_iff /-
+/- warning: order.succ_eq_succ_iff -> Order.succ_eq_succ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align order.succ_eq_succ_iff Order.succ_eq_succ_iffₓ'. -/
 @[simp]
 theorem succ_eq_succ_iff : succ a = succ b ↔ a = b :=
   succ_eq_succ_iff_of_not_isMax (not_isMax a) (not_isMax b)
 #align order.succ_eq_succ_iff Order.succ_eq_succ_iff
--/
 
-#print Order.succ_injective /-
+/- warning: order.succ_injective -> Order.succ_injective is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
+Case conversion may be inaccurate. Consider using '#align order.succ_injective Order.succ_injectiveₓ'. -/
 theorem succ_injective : Injective (succ : α → α) := fun a b => succ_eq_succ_iff.1
 #align order.succ_injective Order.succ_injective
--/
 
-#print Order.succ_ne_succ_iff /-
+/- warning: order.succ_ne_succ_iff -> Order.succ_ne_succ_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align order.succ_ne_succ_iff Order.succ_ne_succ_iffₓ'. -/
 theorem succ_ne_succ_iff : succ a ≠ succ b ↔ a ≠ b :=
   succ_injective.ne_iff
 #align order.succ_ne_succ_iff Order.succ_ne_succ_iff
--/
 
+/- warning: order.succ_ne_succ -> Order.succ_ne_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.succ_ne_succ Order.succ_ne_succₓ'. -/
 alias succ_ne_succ_iff ↔ _ succ_ne_succ
 #align order.succ_ne_succ Order.succ_ne_succ
 
-#print Order.lt_succ_iff_eq_or_lt /-
+/- warning: order.lt_succ_iff_eq_or_lt -> Order.lt_succ_iff_eq_or_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_eq_or_lt Order.lt_succ_iff_eq_or_ltₓ'. -/
 theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b :=
   lt_succ_iff.trans le_iff_eq_or_lt
 #align order.lt_succ_iff_eq_or_lt Order.lt_succ_iff_eq_or_lt
--/
 
-#print Order.succ_eq_iff_covby /-
+/- warning: order.succ_eq_iff_covby -> Order.succ_eq_iff_covby is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
+Case conversion may be inaccurate. Consider using '#align order.succ_eq_iff_covby Order.succ_eq_iff_covbyₓ'. -/
 theorem succ_eq_iff_covby : succ a = b ↔ a ⋖ b :=
   ⟨by
     rintro rfl
     exact covby_succ _, Covby.succ_eq⟩
 #align order.succ_eq_iff_covby Order.succ_eq_iff_covby
--/
 
-#print Order.Iio_succ_eq_insert /-
+/- warning: order.Iio_succ_eq_insert -> Order.Iio_succ_eq_insert is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Iio.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align order.Iio_succ_eq_insert Order.Iio_succ_eq_insertₓ'. -/
 theorem Iio_succ_eq_insert (a : α) : Iio (succ a) = insert a (Iio a) :=
   Iio_succ_eq_insert_of_not_isMax <| not_isMax a
 #align order.Iio_succ_eq_insert Order.Iio_succ_eq_insert
--/
 
-#print Order.Ico_succ_right_eq_insert /-
+/- warning: order.Ico_succ_right_eq_insert -> Order.Ico_succ_right_eq_insert is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ico_succ_right_eq_insert Order.Ico_succ_right_eq_insertₓ'. -/
 theorem Ico_succ_right_eq_insert (h : a ≤ b) : Ico a (succ b) = insert b (Ico a b) :=
   Ico_succ_right_eq_insert_of_not_isMax h <| not_isMax b
 #align order.Ico_succ_right_eq_insert Order.Ico_succ_right_eq_insert
--/
 
-#print Order.Ioo_succ_right_eq_insert /-
+/- warning: order.Ioo_succ_right_eq_insert -> Order.Ioo_succ_right_eq_insert is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) b (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ioo_succ_right_eq_insert Order.Ioo_succ_right_eq_insertₓ'. -/
 theorem Ioo_succ_right_eq_insert (h : a < b) : Ioo a (succ b) = insert b (Ioo a b) :=
   Ioo_succ_right_eq_insert_of_not_isMax h <| not_isMax b
 #align order.Ioo_succ_right_eq_insert Order.Ioo_succ_right_eq_insert
--/
 
 end NoMaxOrder
 
@@ -640,7 +916,7 @@ variable [OrderTop α]
 
 /- warning: order.succ_top -> Order.succ_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 Case conversion may be inaccurate. Consider using '#align order.succ_top Order.succ_topₓ'. -/
@@ -651,7 +927,7 @@ theorem succ_top : succ (⊤ : α) = ⊤ :=
 
 /- warning: order.succ_le_iff_eq_top -> Order.succ_le_iff_eq_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 Case conversion may be inaccurate. Consider using '#align order.succ_le_iff_eq_top Order.succ_le_iff_eq_topₓ'. -/
@@ -662,7 +938,7 @@ theorem succ_le_iff_eq_top : succ a ≤ a ↔ a = ⊤ :=
 
 /- warning: order.lt_succ_iff_ne_top -> Order.lt_succ_iff_ne_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 Case conversion may be inaccurate. Consider using '#align order.lt_succ_iff_ne_top Order.lt_succ_iff_ne_topₓ'. -/
@@ -679,7 +955,7 @@ variable [OrderBot α]
 
 /- warning: order.lt_succ_bot_iff -> Order.lt_succ_bot_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 Case conversion may be inaccurate. Consider using '#align order.lt_succ_bot_iff Order.lt_succ_bot_iffₓ'. -/
@@ -689,7 +965,7 @@ theorem lt_succ_bot_iff [NoMaxOrder α] : a < succ ⊥ ↔ a = ⊥ := by rw [lt_
 
 /- warning: order.le_succ_bot_iff -> Order.le_succ_bot_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Or (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Or (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))) (Or (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
 Case conversion may be inaccurate. Consider using '#align order.le_succ_bot_iff Order.le_succ_bot_iffₓ'. -/
@@ -701,7 +977,7 @@ variable [Nontrivial α]
 
 /- warning: order.bot_lt_succ -> Order.bot_lt_succ is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)
 Case conversion may be inaccurate. Consider using '#align order.bot_lt_succ Order.bot_lt_succₓ'. -/
@@ -711,7 +987,7 @@ theorem bot_lt_succ (a : α) : ⊥ < succ a :=
 
 /- warning: order.succ_ne_bot -> Order.succ_ne_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 Case conversion may be inaccurate. Consider using '#align order.succ_ne_bot Order.succ_ne_botₓ'. -/
@@ -738,7 +1014,7 @@ variable [CompleteLattice α] [SuccOrder α]
 
 /- warning: order.succ_eq_infi -> Order.succ_eq_iInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iInf.{u1, succ u1} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) α (fun (b : α) => iInf.{u1, 0} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
+  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iInf.{u1, succ u1} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) α (fun (b : α) => iInf.{u1, 0} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iInf.{u1, succ u1} α (CompleteLattice.toInfSet.{u1} α _inst_1) α (fun (b : α) => iInf.{u1, 0} α (CompleteLattice.toInfSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
 Case conversion may be inaccurate. Consider using '#align order.succ_eq_infi Order.succ_eq_iInfₓ'. -/
@@ -768,44 +1044,74 @@ def pred : α → α :=
 #align order.pred Order.pred
 -/
 
-#print Order.pred_le /-
+/- warning: order.pred_le -> Order.pred_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (a : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
+Case conversion may be inaccurate. Consider using '#align order.pred_le Order.pred_leₓ'. -/
 theorem pred_le : ∀ a : α, pred a ≤ a :=
   PredOrder.pred_le
 #align order.pred_le Order.pred_le
--/
 
-#print Order.min_of_le_pred /-
+/- warning: order.min_of_le_pred -> Order.min_of_le_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.min_of_le_pred Order.min_of_le_predₓ'. -/
 theorem min_of_le_pred {a : α} : a ≤ pred a → IsMin a :=
   PredOrder.min_of_le_pred
 #align order.min_of_le_pred Order.min_of_le_pred
--/
 
-#print Order.le_pred_of_lt /-
+/- warning: order.le_pred_of_lt -> Order.le_pred_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.le_pred_of_lt Order.le_pred_of_ltₓ'. -/
 theorem le_pred_of_lt {a b : α} : a < b → a ≤ pred b :=
   PredOrder.le_pred_of_lt
 #align order.le_pred_of_lt Order.le_pred_of_lt
--/
 
-#print Order.le_of_pred_lt /-
+/- warning: order.le_of_pred_lt -> Order.le_of_pred_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.le_of_pred_lt Order.le_of_pred_ltₓ'. -/
 theorem le_of_pred_lt {a b : α} : pred a < b → a ≤ b :=
   PredOrder.le_of_pred_lt
 #align order.le_of_pred_lt Order.le_of_pred_lt
--/
 
-#print Order.le_pred_iff_isMin /-
+/- warning: order.le_pred_iff_is_min -> Order.le_pred_iff_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 a)) (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.le_pred_iff_is_min Order.le_pred_iff_isMinₓ'. -/
 @[simp]
 theorem le_pred_iff_isMin : a ≤ pred a ↔ IsMin a :=
   ⟨min_of_le_pred, fun h => h <| pred_le _⟩
 #align order.le_pred_iff_is_min Order.le_pred_iff_isMin
--/
 
-#print Order.pred_lt_iff_not_isMin /-
+/- warning: order.pred_lt_iff_not_is_min -> Order.pred_lt_iff_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) 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 : PredOrder.{u1} α _inst_1] {a : α}, Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a) (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_not_is_min Order.pred_lt_iff_not_isMinₓ'. -/
 @[simp]
 theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a :=
   ⟨not_isMin_of_lt, fun ha => (pred_le a).lt_of_not_le fun h => ha <| min_of_le_pred h⟩
 #align order.pred_lt_iff_not_is_min Order.pred_lt_iff_not_isMin
--/
 
+/- warning: order.pred_lt_of_not_is_min -> Order.pred_lt_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMinₓ'. -/
 alias pred_lt_iff_not_is_min ↔ _ pred_lt_of_not_is_min
 #align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMin
 
@@ -815,187 +1121,309 @@ theorem pred_wcovby (a : α) : pred a ⩿ a :=
 #align order.pred_wcovby Order.pred_wcovby
 -/
 
-#print Order.pred_covby_of_not_isMin /-
+/- warning: order.pred_covby_of_not_is_min -> Order.pred_covby_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a)
+Case conversion may be inaccurate. Consider using '#align order.pred_covby_of_not_is_min Order.pred_covby_of_not_isMinₓ'. -/
 theorem pred_covby_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a :=
   (pred_wcovby a).covby_of_lt <| pred_lt_of_not_isMin h
 #align order.pred_covby_of_not_is_min Order.pred_covby_of_not_isMin
--/
 
-#print Order.pred_lt_iff_of_not_isMin /-
+/- warning: order.pred_lt_iff_of_not_is_min -> Order.pred_lt_iff_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b))
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_of_not_is_min Order.pred_lt_iff_of_not_isMinₓ'. -/
 theorem pred_lt_iff_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a ≤ b :=
   ⟨le_of_pred_lt, (pred_lt_of_not_isMin ha).trans_le⟩
 #align order.pred_lt_iff_of_not_is_min Order.pred_lt_iff_of_not_isMin
--/
 
-#print Order.le_pred_iff_of_not_isMin /-
+/- warning: order.le_pred_iff_of_not_is_min -> Order.le_pred_iff_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b (Order.pred.{u1} α _inst_1 _inst_2 a)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) b a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) b (Order.pred.{u1} α _inst_1 _inst_2 a)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) b a))
+Case conversion may be inaccurate. Consider using '#align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMinₓ'. -/
 theorem le_pred_iff_of_not_isMin (ha : ¬IsMin a) : b ≤ pred a ↔ b < a :=
   ⟨fun h => h.trans_lt <| pred_lt_of_not_isMin ha, le_pred_of_lt⟩
 #align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMin
--/
 
-#print Order.pred_le_pred /-
+/- warning: order.pred_le_pred -> Order.pred_le_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.pred_le_pred Order.pred_le_predₓ'. -/
 @[simp, mono]
 theorem pred_le_pred {a b : α} (h : a ≤ b) : pred a ≤ pred b :=
   succ_le_succ h.dual
 #align order.pred_le_pred Order.pred_le_pred
--/
 
 #print Order.pred_mono /-
 theorem pred_mono : Monotone (pred : α → α) := fun a b => pred_le_pred
 #align order.pred_mono Order.pred_mono
 -/
 
-#print Order.pred_iterate_le /-
+/- warning: order.pred_iterate_le -> Order.pred_iterate_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) k x) x
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] (k : Nat) (x : α), LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) k x) x
+Case conversion may be inaccurate. Consider using '#align order.pred_iterate_le Order.pred_iterate_leₓ'. -/
 theorem pred_iterate_le (k : ℕ) (x : α) : (pred^[k]) x ≤ x :=
   by
   conv_rhs => rw [(by simp only [Function.iterate_id, id.def] : x = (id^[k]) x)]
   exact Monotone.iterate_le_of_le pred_mono pred_le k x
 #align order.pred_iterate_le Order.pred_iterate_le
--/
 
-#print Order.isMin_iterate_pred_of_eq_of_lt /-
+/- warning: order.is_min_iterate_pred_of_eq_of_lt -> Order.isMin_iterate_pred_of_eq_of_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat Nat.hasLt n m) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (LT.lt.{0} Nat instLTNat n m) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
+Case conversion may be inaccurate. Consider using '#align order.is_min_iterate_pred_of_eq_of_lt Order.isMin_iterate_pred_of_eq_of_ltₓ'. -/
 theorem isMin_iterate_pred_of_eq_of_lt {n m : ℕ} (h_eq : (pred^[n]) a = (pred^[m]) a)
     (h_lt : n < m) : IsMin ((pred^[n]) a) :=
   @isMax_iterate_succ_of_eq_of_lt αᵒᵈ _ _ _ _ _ h_eq h_lt
 #align order.is_min_iterate_pred_of_eq_of_lt Order.isMin_iterate_pred_of_eq_of_lt
--/
 
-#print Order.isMin_iterate_pred_of_eq_of_ne /-
+/- warning: order.is_min_iterate_pred_of_eq_of_ne -> Order.isMin_iterate_pred_of_eq_of_ne is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {n : Nat} {m : Nat}, (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) m a)) -> (Ne.{1} Nat n m) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n a))
+Case conversion may be inaccurate. Consider using '#align order.is_min_iterate_pred_of_eq_of_ne Order.isMin_iterate_pred_of_eq_of_neₓ'. -/
 theorem isMin_iterate_pred_of_eq_of_ne {n m : ℕ} (h_eq : (pred^[n]) a = (pred^[m]) a)
     (h_ne : n ≠ m) : IsMin ((pred^[n]) a) :=
   @isMax_iterate_succ_of_eq_of_ne αᵒᵈ _ _ _ _ _ h_eq h_ne
 #align order.is_min_iterate_pred_of_eq_of_ne Order.isMin_iterate_pred_of_eq_of_ne
--/
 
-#print Order.Ioi_pred_of_not_isMin /-
+/- warning: order.Ioi_pred_of_not_is_min -> Order.Ioi_pred_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a))
+Case conversion may be inaccurate. Consider using '#align order.Ioi_pred_of_not_is_min Order.Ioi_pred_of_not_isMinₓ'. -/
 theorem Ioi_pred_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = Ici a :=
   Set.ext fun x => pred_lt_iff_of_not_isMin ha
 #align order.Ioi_pred_of_not_is_min Order.Ioi_pred_of_not_isMin
--/
 
-#print Order.Iic_pred_of_not_isMin /-
+/- warning: order.Iic_pred_of_not_is_min -> Order.Iic_pred_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a))
+Case conversion may be inaccurate. Consider using '#align order.Iic_pred_of_not_is_min Order.Iic_pred_of_not_isMinₓ'. -/
 theorem Iic_pred_of_not_isMin (ha : ¬IsMin a) : Iic (pred a) = Iio a :=
   Set.ext fun x => le_pred_iff_of_not_isMin ha
 #align order.Iic_pred_of_not_is_min Order.Iic_pred_of_not_isMin
--/
 
-#print Order.Ioc_pred_left_of_not_isMin /-
+/- warning: order.Ioc_pred_left_of_not_is_min -> Order.Ioc_pred_left_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_left_of_not_is_min Order.Ioc_pred_left_of_not_isMinₓ'. -/
 theorem Ioc_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioc (pred a) b = Icc a b := by
   rw [← Ioi_inter_Iic, Ioi_pred_of_not_is_min ha, Ici_inter_Iic]
 #align order.Ioc_pred_left_of_not_is_min Order.Ioc_pred_left_of_not_isMin
--/
 
-#print Order.Ioo_pred_left_of_not_isMin /-
+/- warning: order.Ioo_pred_left_of_not_is_min -> Order.Ioo_pred_left_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Ioo_pred_left_of_not_is_min Order.Ioo_pred_left_of_not_isMinₓ'. -/
 theorem Ioo_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioo (pred a) b = Ico a b := by
   rw [← Ioi_inter_Iio, Ioi_pred_of_not_is_min ha, Ici_inter_Iio]
 #align order.Ioo_pred_left_of_not_is_min Order.Ioo_pred_left_of_not_isMin
--/
 
-#print Order.Icc_pred_right_of_not_isMin /-
+/- warning: order.Icc_pred_right_of_not_is_min -> Order.Icc_pred_right_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Icc_pred_right_of_not_is_min Order.Icc_pred_right_of_not_isMinₓ'. -/
 theorem Icc_pred_right_of_not_isMin (ha : ¬IsMin b) : Icc a (pred b) = Ico a b := by
   rw [← Ici_inter_Iic, Iic_pred_of_not_is_min ha, Ici_inter_Iio]
 #align order.Icc_pred_right_of_not_is_min Order.Icc_pred_right_of_not_isMin
--/
 
-#print Order.Ioc_pred_right_of_not_isMin /-
+/- warning: order.Ioc_pred_right_of_not_is_min -> Order.Ioc_pred_right_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) b)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b))
+Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_right_of_not_is_min Order.Ioc_pred_right_of_not_isMinₓ'. -/
 theorem Ioc_pred_right_of_not_isMin (ha : ¬IsMin b) : Ioc a (pred b) = Ioo a b := by
   rw [← Ioi_inter_Iic, Iic_pred_of_not_is_min ha, Ioi_inter_Iio]
 #align order.Ioc_pred_right_of_not_is_min Order.Ioc_pred_right_of_not_isMin
--/
 
 section NoMinOrder
 
 variable [NoMinOrder α]
 
-#print Order.pred_lt /-
+/- warning: order.pred_lt -> Order.pred_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
+Case conversion may be inaccurate. Consider using '#align order.pred_lt Order.pred_ltₓ'. -/
 theorem pred_lt (a : α) : pred a < a :=
   pred_lt_of_not_isMin <| not_isMin a
 #align order.pred_lt Order.pred_lt
--/
 
-#print Order.pred_lt_iff /-
+/- warning: order.pred_lt_iff -> Order.pred_lt_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) b) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff Order.pred_lt_iffₓ'. -/
 @[simp]
 theorem pred_lt_iff : pred a < b ↔ a ≤ b :=
   pred_lt_iff_of_not_isMin <| not_isMin a
 #align order.pred_lt_iff Order.pred_lt_iff
--/
 
-#print Order.le_pred_iff /-
+/- warning: order.le_pred_iff -> Order.le_pred_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.le_pred_iff Order.le_pred_iffₓ'. -/
 @[simp]
 theorem le_pred_iff : a ≤ pred b ↔ a < b :=
   le_pred_iff_of_not_isMin <| not_isMin b
 #align order.le_pred_iff Order.le_pred_iff
--/
 
-#print Order.pred_le_pred_iff /-
+/- warning: order.pred_le_pred_iff -> Order.pred_le_pred_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.pred_le_pred_iff Order.pred_le_pred_iffₓ'. -/
 theorem pred_le_pred_iff : pred a ≤ pred b ↔ a ≤ b := by simp
 #align order.pred_le_pred_iff Order.pred_le_pred_iff
--/
 
-#print Order.pred_lt_pred_iff /-
+/- warning: order.pred_lt_pred_iff -> Order.pred_lt_pred_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_pred_iff Order.pred_lt_pred_iffₓ'. -/
 theorem pred_lt_pred_iff : pred a < pred b ↔ a < b := by simp
 #align order.pred_lt_pred_iff Order.pred_lt_pred_iff
--/
 
+/- warning: order.le_of_pred_le_pred -> Order.le_of_pred_le_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.le_of_pred_le_pred Order.le_of_pred_le_predₓ'. -/
 alias pred_le_pred_iff ↔ le_of_pred_le_pred _
 #align order.le_of_pred_le_pred Order.le_of_pred_le_pred
 
+/- warning: order.lt_of_pred_lt_pred -> Order.lt_of_pred_lt_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b)) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align order.lt_of_pred_lt_pred Order.lt_of_pred_lt_predₓ'. -/
+/- warning: order.pred_lt_pred -> Order.pred_lt_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) (Order.pred.{u1} α _inst_1 _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_pred Order.pred_lt_predₓ'. -/
 alias pred_lt_pred_iff ↔ lt_of_pred_lt_pred pred_lt_pred
 #align order.lt_of_pred_lt_pred Order.lt_of_pred_lt_pred
 #align order.pred_lt_pred Order.pred_lt_pred
 
-#print Order.pred_strictMono /-
+/- warning: order.pred_strict_mono -> Order.pred_strictMono is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.pred.{u1} α _inst_1 _inst_2)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], StrictMono.{u1, u1} α α _inst_1 _inst_1 (Order.pred.{u1} α _inst_1 _inst_2)
+Case conversion may be inaccurate. Consider using '#align order.pred_strict_mono Order.pred_strictMonoₓ'. -/
 theorem pred_strictMono : StrictMono (pred : α → α) := fun a b => pred_lt_pred
 #align order.pred_strict_mono Order.pred_strictMono
--/
 
-#print Order.pred_covby /-
+/- warning: order.pred_covby -> Order.pred_covby is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Covby.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a) a
+Case conversion may be inaccurate. Consider using '#align order.pred_covby Order.pred_covbyₓ'. -/
 theorem pred_covby (a : α) : pred a ⋖ a :=
   pred_covby_of_not_isMin <| not_isMin a
 #align order.pred_covby Order.pred_covby
--/
 
-#print Order.Ioi_pred /-
+/- warning: order.Ioi_pred -> Order.Ioi_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Ici.{u1} α _inst_1 a)
+Case conversion may be inaccurate. Consider using '#align order.Ioi_pred Order.Ioi_predₓ'. -/
 @[simp]
 theorem Ioi_pred (a : α) : Ioi (pred a) = Ici a :=
   Ioi_pred_of_not_isMin <| not_isMin a
 #align order.Ioi_pred Order.Ioi_pred
--/
 
-#print Order.Iic_pred /-
+/- warning: order.Iic_pred -> Order.Iic_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Iic.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a)) (Set.Iio.{u1} α _inst_1 a)
+Case conversion may be inaccurate. Consider using '#align order.Iic_pred Order.Iic_predₓ'. -/
 @[simp]
 theorem Iic_pred (a : α) : Iic (pred a) = Iio a :=
   Iic_pred_of_not_isMin <| not_isMin a
 #align order.Iic_pred Order.Iic_pred
--/
 
-#print Order.Ioc_pred_left /-
+/- warning: order.Ioc_pred_left -> Order.Ioc_pred_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Icc.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_left Order.Ioc_pred_leftₓ'. -/
 @[simp]
 theorem Ioc_pred_left (a b : α) : Ioc (pred a) b = Icc a b :=
   Ioc_pred_left_of_not_isMin <| not_isMin _
 #align order.Ioc_pred_left Order.Ioc_pred_left
--/
 
-#print Order.Ioo_pred_left /-
+/- warning: order.Ioo_pred_left -> Order.Ioo_pred_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α _inst_1 (Order.pred.{u1} α _inst_1 _inst_2 a) b) (Set.Ico.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Ioo_pred_left Order.Ioo_pred_leftₓ'. -/
 @[simp]
 theorem Ioo_pred_left (a b : α) : Ioo (pred a) b = Ico a b :=
   Ioo_pred_left_of_not_isMin <| not_isMin _
 #align order.Ioo_pred_left Order.Ioo_pred_left
--/
 
-#print Order.Icc_pred_right /-
+/- warning: order.Icc_pred_right -> Order.Icc_pred_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ico.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Icc_pred_right Order.Icc_pred_rightₓ'. -/
 @[simp]
 theorem Icc_pred_right (a b : α) : Icc a (pred b) = Ico a b :=
   Icc_pred_right_of_not_isMin <| not_isMin _
 #align order.Icc_pred_right Order.Icc_pred_right
--/
 
-#print Order.Ioc_pred_right /-
+/- warning: order.Ioc_pred_right -> Order.Ioc_pred_right is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] (a : α) (b : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α _inst_1 a (Order.pred.{u1} α _inst_1 _inst_2 b)) (Set.Ioo.{u1} α _inst_1 a b)
+Case conversion may be inaccurate. Consider using '#align order.Ioc_pred_right Order.Ioc_pred_rightₓ'. -/
 @[simp]
 theorem Ioc_pred_right (a b : α) : Ioc a (pred b) = Ioo a b :=
   Ioc_pred_right_of_not_isMin <| not_isMin _
 #align order.Ioc_pred_right Order.Ioc_pred_right
--/
 
 end NoMinOrder
 
@@ -1005,17 +1433,32 @@ section PartialOrder
 
 variable [PartialOrder α] [PredOrder α] {a b : α}
 
-#print Order.pred_eq_iff_isMin /-
+/- warning: order.pred_eq_iff_is_min -> Order.pred_eq_iff_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.pred_eq_iff_is_min Order.pred_eq_iff_isMinₓ'. -/
 @[simp]
 theorem pred_eq_iff_isMin : pred a = a ↔ IsMin a :=
   ⟨fun h => min_of_le_pred h.ge, fun h => h.eq_of_le <| pred_le _⟩
 #align order.pred_eq_iff_is_min Order.pred_eq_iff_isMin
--/
 
+/- warning: is_min.pred_eq -> IsMin.pred_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a)
+Case conversion may be inaccurate. Consider using '#align is_min.pred_eq IsMin.pred_eqₓ'. -/
 alias pred_eq_iff_is_min ↔ _ _root_.is_min.pred_eq
 #align is_min.pred_eq IsMin.pred_eq
 
-#print Order.pred_le_le_iff /-
+/- warning: order.pred_le_le_iff -> Order.pred_le_le_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a)) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (And (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b a)) (Or (Eq.{succ u1} α b a) (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)))
+Case conversion may be inaccurate. Consider using '#align order.pred_le_le_iff Order.pred_le_le_iffₓ'. -/
 theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a :=
   by
   refine'
@@ -1025,37 +1468,52 @@ theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = p
   · exact ⟨pred_le b, le_rfl⟩
   · exact ⟨le_rfl, pred_le a⟩
 #align order.pred_le_le_iff Order.pred_le_le_iff
--/
 
-#print Covby.pred_eq /-
+/- warning: covby.pred_eq -> Covby.pred_eq is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
+Case conversion may be inaccurate. Consider using '#align covby.pred_eq Covby.pred_eqₓ'. -/
 theorem Covby.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
   (le_pred_of_lt h.lt).eq_of_not_gt fun h' => h.2 h' <| pred_lt_of_not_isMin h.lt.not_isMin
 #align covby.pred_eq Covby.pred_eq
--/
 
-#print Wcovby.pred_le /-
+/- warning: wcovby.pred_le -> Wcovby.pred_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Wcovby.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b) -> (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
+Case conversion may be inaccurate. Consider using '#align wcovby.pred_le Wcovby.pred_leₓ'. -/
 theorem Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.pred_eq.le
   · exact pred_le _
 #align wcovby.pred_le Wcovby.pred_le
--/
 
-#print Order.pred_le_iff_eq_or_le /-
+/- warning: order.pred_le_iff_eq_or_le -> Order.pred_le_iff_eq_or_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α b (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+Case conversion may be inaccurate. Consider using '#align order.pred_le_iff_eq_or_le Order.pred_le_iff_eq_or_leₓ'. -/
 theorem pred_le_iff_eq_or_le : pred a ≤ b ↔ b = pred a ∨ a ≤ b :=
   by
   by_cases ha : IsMin a
   · rw [ha.pred_eq, or_iff_right_of_imp ge_of_eq]
   · rw [← pred_lt_iff_of_not_is_min ha, le_iff_eq_or_lt, eq_comm]
 #align order.pred_le_iff_eq_or_le Order.pred_le_iff_eq_or_le
--/
 
-#print Order.pred_lt_iff_eq_or_lt_of_not_isMin /-
+/- warning: order.pred_lt_iff_eq_or_lt_of_not_is_min -> Order.pred_lt_iff_eq_or_lt_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)))
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_eq_or_lt_of_not_is_min Order.pred_lt_iff_eq_or_lt_of_not_isMinₓ'. -/
 theorem pred_lt_iff_eq_or_lt_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a = b ∨ a < b :=
   (pred_lt_iff_of_not_isMin ha).trans le_iff_eq_or_lt
 #align order.pred_lt_iff_eq_or_lt_of_not_is_min Order.pred_lt_iff_eq_or_lt_of_not_isMin
--/
 
 #print Order.Ici_pred /-
 theorem Ici_pred (a : α) : Ici (pred a) = insert (pred a) (Ici a) :=
@@ -1063,82 +1521,132 @@ theorem Ici_pred (a : α) : Ici (pred a) = insert (pred a) (Ici a) :=
 #align order.Ici_pred Order.Ici_pred
 -/
 
-#print Order.Ioi_pred_eq_insert_of_not_isMin /-
+/- warning: order.Ioi_pred_eq_insert_of_not_is_min -> Order.Ioi_pred_eq_insert_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a)))
+Case conversion may be inaccurate. Consider using '#align order.Ioi_pred_eq_insert_of_not_is_min Order.Ioi_pred_eq_insert_of_not_isMinₓ'. -/
 theorem Ioi_pred_eq_insert_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = insert a (Ioi a) :=
   by
   ext x; simp only [insert, mem_set_of, @eq_comm _ x a]
   exact pred_lt_iff_eq_or_lt_of_not_is_min ha
 #align order.Ioi_pred_eq_insert_of_not_is_min Order.Ioi_pred_eq_insert_of_not_isMin
--/
 
-#print Order.Icc_pred_left /-
+/- warning: order.Icc_pred_left -> Order.Icc_pred_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Icc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Icc_pred_left Order.Icc_pred_leftₓ'. -/
 theorem Icc_pred_left (h : pred a ≤ b) : Icc (pred a) b = insert (pred a) (Icc a b) := by
   simp_rw [← Ici_inter_Iic, Ici_pred, insert_inter_of_mem (mem_Iic.2 h)]
 #align order.Icc_pred_left Order.Icc_pred_left
--/
 
-#print Order.Ico_pred_left /-
+/- warning: order.Ico_pred_left -> Order.Ico_pred_left is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Set.Ico.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ico_pred_left Order.Ico_pred_leftₓ'. -/
 theorem Ico_pred_left (h : pred a < b) : Ico (pred a) b = insert (pred a) (Ico a b) := by
   simp_rw [← Ici_inter_Iio, Ici_pred, insert_inter_of_mem (mem_Iio.2 h)]
 #align order.Ico_pred_left Order.Ico_pred_left
--/
 
 section NoMinOrder
 
 variable [NoMinOrder α]
 
-#print Order.pred_eq_pred_iff /-
+/- warning: order.pred_eq_pred_iff -> Order.pred_eq_pred_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Eq.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align order.pred_eq_pred_iff Order.pred_eq_pred_iffₓ'. -/
 @[simp]
 theorem pred_eq_pred_iff : pred a = pred b ↔ a = b := by
   simp_rw [eq_iff_le_not_lt, pred_le_pred_iff, pred_lt_pred_iff]
 #align order.pred_eq_pred_iff Order.pred_eq_pred_iff
--/
 
-#print Order.pred_injective /-
+/- warning: order.pred_injective -> Order.pred_injective is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Function.Injective.{succ u1, succ u1} α α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)
+Case conversion may be inaccurate. Consider using '#align order.pred_injective Order.pred_injectiveₓ'. -/
 theorem pred_injective : Injective (pred : α → α) := fun a b => pred_eq_pred_iff.1
 #align order.pred_injective Order.pred_injective
--/
 
-#print Order.pred_ne_pred_iff /-
+/- warning: order.pred_ne_pred_iff -> Order.pred_ne_pred_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Ne.{succ u1} α a b)
+Case conversion may be inaccurate. Consider using '#align order.pred_ne_pred_iff Order.pred_ne_pred_iffₓ'. -/
 theorem pred_ne_pred_iff : pred a ≠ pred b ↔ a ≠ b :=
   pred_injective.ne_iff
 #align order.pred_ne_pred_iff Order.pred_ne_pred_iff
--/
 
+/- warning: order.pred_ne_pred -> Order.pred_ne_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (Ne.{succ u1} α a b) -> (Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.pred_ne_pred Order.pred_ne_predₓ'. -/
 alias pred_ne_pred_iff ↔ _ pred_ne_pred
 #align order.pred_ne_pred Order.pred_ne_pred
 
-#print Order.pred_lt_iff_eq_or_lt /-
+/- warning: order.pred_lt_iff_eq_or_lt -> Order.pred_lt_iff_eq_or_lt is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Or (Eq.{succ u1} α a b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_eq_or_lt Order.pred_lt_iff_eq_or_ltₓ'. -/
 theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b :=
   pred_lt_iff.trans le_iff_eq_or_lt
 #align order.pred_lt_iff_eq_or_lt Order.pred_lt_iff_eq_or_lt
--/
 
-#print Order.pred_eq_iff_covby /-
+/- warning: order.pred_eq_iff_covby -> Order.pred_eq_iff_covby is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) (Covby.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) (Covby.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b)
+Case conversion may be inaccurate. Consider using '#align order.pred_eq_iff_covby Order.pred_eq_iff_covbyₓ'. -/
 theorem pred_eq_iff_covby : pred b = a ↔ a ⋖ b :=
   ⟨by
     rintro rfl
     exact pred_covby _, Covby.pred_eq⟩
 #align order.pred_eq_iff_covby Order.pred_eq_iff_covby
--/
 
-#print Order.Ioi_pred_eq_insert /-
+/- warning: order.Ioi_pred_eq_insert -> Order.Ioi_pred_eq_insert is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} (Set.{u1} α) (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioi.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a))
+Case conversion may be inaccurate. Consider using '#align order.Ioi_pred_eq_insert Order.Ioi_pred_eq_insertₓ'. -/
 theorem Ioi_pred_eq_insert (a : α) : Ioi (pred a) = insert a (Ioi a) :=
   ext fun _ => pred_lt_iff_eq_or_lt.trans <| or_congr_left eq_comm
 #align order.Ioi_pred_eq_insert Order.Ioi_pred_eq_insert
--/
 
-#print Order.Ico_pred_right_eq_insert /-
+/- warning: order.Ico_pred_right_eq_insert -> Order.Ico_pred_right_eq_insert is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioc.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ico_pred_right_eq_insert Order.Ico_pred_right_eq_insertₓ'. -/
 theorem Ico_pred_right_eq_insert (h : a ≤ b) : Ioc (pred a) b = insert a (Ioc a b) := by
   simp_rw [← Ioi_inter_Iic, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iic.2 h)]
 #align order.Ico_pred_right_eq_insert Order.Ico_pred_right_eq_insert
--/
 
-#print Order.Ioo_pred_right_eq_insert /-
+/- warning: order.Ioo_pred_right_eq_insert -> Order.Ioo_pred_right_eq_insert is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.hasInsert.{u1} α) a (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} {b : α} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (Eq.{succ u1} (Set.{u1} α) (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (Insert.insert.{u1, u1} α (Set.{u1} α) (Set.instInsertSet.{u1} α) a (Set.Ioo.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) a b)))
+Case conversion may be inaccurate. Consider using '#align order.Ioo_pred_right_eq_insert Order.Ioo_pred_right_eq_insertₓ'. -/
 theorem Ioo_pred_right_eq_insert (h : a < b) : Ioo (pred a) b = insert a (Ioo a b) := by
   simp_rw [← Ioi_inter_Iio, Ioi_pred_eq_insert, insert_inter_of_mem (mem_Iio.2 h)]
 #align order.Ioo_pred_right_eq_insert Order.Ioo_pred_right_eq_insert
--/
 
 end NoMinOrder
 
@@ -1148,7 +1656,7 @@ variable [OrderBot α]
 
 /- warning: order.pred_bot -> Order.pred_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 Case conversion may be inaccurate. Consider using '#align order.pred_bot Order.pred_botₓ'. -/
@@ -1159,7 +1667,7 @@ theorem pred_bot : pred (⊥ : α) = ⊥ :=
 
 /- warning: order.le_pred_iff_eq_bot -> Order.le_pred_iff_eq_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) (Eq.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 Case conversion may be inaccurate. Consider using '#align order.le_pred_iff_eq_bot Order.le_pred_iff_eq_botₓ'. -/
@@ -1170,7 +1678,7 @@ theorem le_pred_iff_eq_bot : a ≤ pred a ↔ a = ⊥ :=
 
 /- warning: order.pred_lt_iff_ne_bot -> Order.pred_lt_iff_ne_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) a) (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 Case conversion may be inaccurate. Consider using '#align order.pred_lt_iff_ne_bot Order.pred_lt_iff_ne_botₓ'. -/
@@ -1187,7 +1695,7 @@ variable [OrderTop α]
 
 /- warning: order.pred_top_lt_iff -> Order.pred_top_lt_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))
 Case conversion may be inaccurate. Consider using '#align order.pred_top_lt_iff Order.pred_top_lt_iffₓ'. -/
@@ -1198,7 +1706,7 @@ theorem pred_top_lt_iff [NoMinOrder α] : pred ⊤ < a ↔ a = ⊤ :=
 
 /- warning: order.pred_top_le_iff -> Order.pred_top_le_iff is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Or (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Or (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (LE.le.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) a) (Or (Eq.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))) (Eq.{succ u1} α a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3)))))
 Case conversion may be inaccurate. Consider using '#align order.pred_top_le_iff Order.pred_top_le_iffₓ'. -/
@@ -1210,7 +1718,7 @@ variable [Nontrivial α]
 
 /- warning: order.pred_lt_top -> Order.pred_lt_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 Case conversion may be inaccurate. Consider using '#align order.pred_lt_top Order.pred_lt_topₓ'. -/
@@ -1220,7 +1728,7 @@ theorem pred_lt_top (a : α) : pred a < ⊤ :=
 
 /- warning: order.pred_ne_top -> Order.pred_ne_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] [_inst_4 : Nontrivial.{u1} α] (a : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) _inst_3))
 Case conversion may be inaccurate. Consider using '#align order.pred_ne_top Order.pred_ne_topₓ'. -/
@@ -1247,7 +1755,7 @@ variable [CompleteLattice α] [PredOrder α]
 
 /- warning: order.pred_eq_supr -> Order.pred_eq_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iSup.{u1, succ u1} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) α (fun (b : α) => iSup.{u1, 0} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
+  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iSup.{u1, succ u1} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) α (fun (b : α) => iSup.{u1, 0} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iSup.{u1, succ u1} α (CompleteLattice.toSupSet.{u1} α _inst_1) α (fun (b : α) => iSup.{u1, 0} α (CompleteLattice.toSupSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
 Case conversion may be inaccurate. Consider using '#align order.pred_eq_supr Order.pred_eq_iSupₓ'. -/
@@ -1269,35 +1777,56 @@ section SuccPredOrder
 
 variable [PartialOrder α] [SuccOrder α] [PredOrder α] {a b : α}
 
-#print Order.succ_pred_of_not_isMin /-
+/- warning: order.succ_pred_of_not_is_min -> Order.succ_pred_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a)
+Case conversion may be inaccurate. Consider using '#align order.succ_pred_of_not_is_min Order.succ_pred_of_not_isMinₓ'. -/
 @[simp]
 theorem succ_pred_of_not_isMin (h : ¬IsMin a) : succ (pred a) = a :=
   (pred_covby_of_not_isMin h).succ_eq
 #align order.succ_pred_of_not_is_min Order.succ_pred_of_not_isMin
--/
 
-#print Order.pred_succ_of_not_isMax /-
+/- warning: order.pred_succ_of_not_is_max -> Order.pred_succ_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a)
+Case conversion may be inaccurate. Consider using '#align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMaxₓ'. -/
 @[simp]
 theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a :=
   (covby_succ_of_not_isMax h).pred_eq
 #align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMax
--/
 
-#print Order.succ_pred /-
+/- warning: order.succ_pred -> Order.succ_pred is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 a)) a
+Case conversion may be inaccurate. Consider using '#align order.succ_pred Order.succ_predₓ'. -/
 @[simp]
 theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a :=
   (pred_covby _).succ_eq
 #align order.succ_pred Order.succ_pred
--/
 
-#print Order.pred_succ /-
+/- warning: order.pred_succ -> Order.pred_succ is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a)) a
+Case conversion may be inaccurate. Consider using '#align order.pred_succ Order.pred_succₓ'. -/
 @[simp]
 theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
   (covby_succ _).pred_eq
 #align order.pred_succ Order.pred_succ
--/
 
-#print Order.pred_succ_iterate_of_not_isMax /-
+/- warning: order.pred_succ_iterate_of_not_is_max -> Order.pred_succ_iterate_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n i)) i)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n i)) i)
+Case conversion may be inaccurate. Consider using '#align order.pred_succ_iterate_of_not_is_max Order.pred_succ_iterate_of_not_isMaxₓ'. -/
 theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^[n - 1]) i)) :
     (pred^[n]) ((succ^[n]) i) = i := by
   induction' n with n hn
@@ -1320,14 +1849,17 @@ theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax ((succ^
   rw [pred_succ_of_not_is_max hin]
   exact hn h_not_max
 #align order.pred_succ_iterate_of_not_is_max Order.pred_succ_iterate_of_not_isMax
--/
 
-#print Order.succ_pred_iterate_of_not_isMin /-
+/- warning: order.succ_pred_iterate_of_not_is_min -> Order.succ_pred_iterate_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat Nat.hasSub) n (OfNat.ofNat.{0} Nat 1 (OfNat.mk.{0} Nat 1 (One.one.{0} Nat Nat.hasOne)))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n i)) i)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] (i : α) (n : Nat), (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) (HSub.hSub.{0, 0, 0} Nat Nat Nat (instHSub.{0} Nat instSubNat) n (OfNat.ofNat.{0} Nat 1 (instOfNatNat 1))) i))) -> (Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2) n (Nat.iterate.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3) n i)) i)
+Case conversion may be inaccurate. Consider using '#align order.succ_pred_iterate_of_not_is_min Order.succ_pred_iterate_of_not_isMinₓ'. -/
 theorem succ_pred_iterate_of_not_isMin (i : α) (n : ℕ) (hin : ¬IsMin ((pred^[n - 1]) i)) :
     (succ^[n]) ((pred^[n]) i) = i :=
   @pred_succ_iterate_of_not_isMax αᵒᵈ _ _ _ i n hin
 #align order.succ_pred_iterate_of_not_is_min Order.succ_pred_iterate_of_not_isMin
--/
 
 end SuccPredOrder
 
@@ -1404,7 +1936,7 @@ instance : SuccOrder (WithTop α)
 
 /- warning: with_top.succ_coe_top -> WithTop.succ_coe_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.succOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.succOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.instSuccOrderWithTopPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))
 Case conversion may be inaccurate. Consider using '#align with_top.succ_coe_top WithTop.succ_coe_topₓ'. -/
@@ -1415,7 +1947,7 @@ theorem succ_coe_top : succ ↑(⊤ : α) = (⊤ : WithTop α) :=
 
 /- warning: with_top.succ_coe_of_ne_top -> WithTop.succ_coe_of_ne_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.succOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.succOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithTop.instSuccOrderWithTopPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithTop.some.{u1} α a)) (WithTop.some.{u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
 Case conversion may be inaccurate. Consider using '#align with_top.succ_coe_of_ne_top WithTop.succ_coe_of_ne_topₓ'. -/
@@ -1458,7 +1990,7 @@ instance : PredOrder (WithTop α)
 
 /- warning: with_top.pred_top -> WithTop.pred_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align with_top.pred_top WithTop.pred_topₓ'. -/
@@ -1467,16 +1999,20 @@ theorem pred_top : pred (⊤ : WithTop α) = ↑(⊤ : α) :=
   rfl
 #align with_top.pred_top WithTop.pred_top
 
-#print WithTop.pred_coe /-
+/- warning: with_top.pred_coe -> WithTop.pred_coe is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) (WithTop.some.{u1} α a)) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))
+Case conversion may be inaccurate. Consider using '#align with_top.pred_coe WithTop.pred_coeₓ'. -/
 @[simp]
 theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
   rfl
 #align with_top.pred_coe WithTop.pred_coe
--/
 
 /- warning: with_top.pred_untop -> WithTop.pred_untop is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (WithTop.pred_top.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (WithTop.pred_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Order.pred.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (WithTop.pred_top.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (WithTop.pred_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Order.pred.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) not_false_eq_true)) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))) not_false_eq_true)) a ha))
 Case conversion may be inaccurate. Consider using '#align with_top.pred_untop WithTop.pred_untopₓ'. -/
@@ -1497,7 +2033,12 @@ section Succ
 
 variable [Preorder α] [NoMaxOrder α] [SuccOrder α]
 
-#print WithTop.succOrderOfNoMaxOrder /-
+/- warning: with_top.succ_order_of_no_max_order -> WithTop.succOrderOfNoMaxOrder is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], SuccOrder.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], SuccOrder.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1)
+Case conversion may be inaccurate. Consider using '#align with_top.succ_order_of_no_max_order WithTop.succOrderOfNoMaxOrderₓ'. -/
 instance succOrderOfNoMaxOrder : SuccOrder (WithTop α)
     where
   succ a :=
@@ -1525,14 +2066,17 @@ instance succOrderOfNoMaxOrder : SuccOrder (WithTop α)
     · exact le_top
     · exact some_le_some.2 (le_of_lt_succ <| some_lt_some.1 h)
 #align with_top.succ_order_of_no_max_order WithTop.succOrderOfNoMaxOrder
--/
 
-#print WithTop.succ_coe /-
+/- warning: with_top.succ_coe -> WithTop.succ_coe is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.succOrderOfNoMaxOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithTop.{u1} α) (Order.succ.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.succOrderOfNoMaxOrder.{u1} α _inst_1 _inst_2 _inst_3) (WithTop.some.{u1} α a)) (WithTop.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))
+Case conversion may be inaccurate. Consider using '#align with_top.succ_coe WithTop.succ_coeₓ'. -/
 @[simp]
 theorem succ_coe (a : α) : succ (↑a : WithTop α) = ↑(succ a) :=
   rfl
 #align with_top.succ_coe WithTop.succ_coe
--/
 
 end Succ
 
@@ -1591,7 +2135,7 @@ instance : SuccOrder (WithBot α)
 
 /- warning: with_bot.succ_bot -> WithBot.succ_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1], Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align with_bot.succ_bot WithBot.succ_botₓ'. -/
@@ -1600,16 +2144,20 @@ theorem succ_bot : succ (⊥ : WithBot α) = ↑(⊥ : α) :=
   rfl
 #align with_bot.succ_bot WithBot.succ_bot
 
-#print WithBot.succ_coe /-
+/- warning: with_bot.succ_coe -> WithBot.succ_coe is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) (WithBot.some.{u1} α a)) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))
+Case conversion may be inaccurate. Consider using '#align with_bot.succ_coe WithBot.succ_coeₓ'. -/
 @[simp]
 theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
   rfl
 #align with_bot.succ_coe WithBot.succ_coe
--/
 
 /- warning: with_bot.succ_unbot -> WithBot.succ_unbot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (WithBot.succ_bot.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (WithBot.succ_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Order.succ.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (WithBot.succ_bot.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (WithBot.succ_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Order.succ.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) not_false_eq_true)) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))) not_false_eq_true)) a ha))
 Case conversion may be inaccurate. Consider using '#align with_bot.succ_unbot WithBot.succ_unbotₓ'. -/
@@ -1673,7 +2221,7 @@ instance : PredOrder (WithBot α)
 
 /- warning: with_bot.pred_coe_bot -> WithBot.pred_coe_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.predOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.predOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)], Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.instPredOrderWithBotPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3)))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))
 Case conversion may be inaccurate. Consider using '#align with_bot.pred_coe_bot WithBot.pred_coe_botₓ'. -/
@@ -1684,7 +2232,7 @@ theorem pred_coe_bot : pred ↑(⊥ : α) = (⊥ : WithBot α) :=
 
 /- warning: with_bot.pred_coe_of_ne_bot -> WithBot.pred_coe_of_ne_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.predOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
+  forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.predOrder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : DecidableEq.{succ u1} α] [_inst_2 : PartialOrder.{u1} α] [_inst_3 : OrderBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2))] [_inst_4 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)] {a : α}, (Ne.{succ u1} α a (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) _inst_3))) -> (Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2)) (WithBot.instPredOrderWithBotPreorderToPreorder.{u1} α (fun (a : α) (b : α) => _inst_1 a b) _inst_2 _inst_3 _inst_4) (WithBot.some.{u1} α a)) (WithBot.some.{u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_2) _inst_4 a)))
 Case conversion may be inaccurate. Consider using '#align with_bot.pred_coe_of_ne_bot WithBot.pred_coe_of_ne_botₓ'. -/
@@ -1716,7 +2264,12 @@ section Pred
 
 variable [Preorder α] [NoMinOrder α] [PredOrder α]
 
-#print WithBot.predOrderOfNoMinOrder /-
+/- warning: with_bot.pred_order_of_no_min_order -> WithBot.predOrderOfNoMinOrder is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], PredOrder.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1], PredOrder.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1)
+Case conversion may be inaccurate. Consider using '#align with_bot.pred_order_of_no_min_order WithBot.predOrderOfNoMinOrderₓ'. -/
 instance predOrderOfNoMinOrder : PredOrder (WithBot α)
     where
   pred a :=
@@ -1744,14 +2297,17 @@ instance predOrderOfNoMinOrder : PredOrder (WithBot α)
     · exact bot_le
     · exact some_le_some.2 (le_of_pred_lt <| some_lt_some.1 h)
 #align with_bot.pred_order_of_no_min_order WithBot.predOrderOfNoMinOrder
--/
 
-#print WithBot.pred_coe /-
+/- warning: with_bot.pred_coe -> WithBot.pred_coe is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.predOrderOfNoMinOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : α), Eq.{succ u1} (WithBot.{u1} α) (Order.pred.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.predOrderOfNoMinOrder.{u1} α _inst_1 _inst_2 _inst_3) (WithBot.some.{u1} α a)) (WithBot.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))
+Case conversion may be inaccurate. Consider using '#align with_bot.pred_coe WithBot.pred_coeₓ'. -/
 @[simp]
 theorem pred_coe (a : α) : pred (↑a : WithBot α) = ↑(pred a) :=
   rfl
 #align with_bot.pred_coe WithBot.pred_coe
--/
 
 end Pred
 
@@ -1791,22 +2347,35 @@ variable [SuccOrder α] [IsSuccArchimedean α] {a b : α}
 instance : IsPredArchimedean αᵒᵈ :=
   ⟨fun a b h => by convert exists_succ_iterate_of_le h.of_dual⟩
 
-#print LE.le.exists_succ_iterate /-
+/- warning: has_le.le.exists_succ_iterate -> LE.le.exists_succ_iterate is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b))
+Case conversion may be inaccurate. Consider using '#align has_le.le.exists_succ_iterate LE.le.exists_succ_iterateₓ'. -/
 theorem LE.le.exists_succ_iterate (h : a ≤ b) : ∃ n, (succ^[n]) a = b :=
   exists_succ_iterate_of_le h
 #align has_le.le.exists_succ_iterate LE.le.exists_succ_iterate
--/
 
-#print exists_succ_iterate_iff_le /-
+/- warning: exists_succ_iterate_iff_le -> exists_succ_iterate_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2) n a) b)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align exists_succ_iterate_iff_le exists_succ_iterate_iff_leₓ'. -/
 theorem exists_succ_iterate_iff_le : (∃ n, (succ^[n]) a = b) ↔ a ≤ b :=
   by
   refine' ⟨_, exists_succ_iterate_of_le⟩
   rintro ⟨n, rfl⟩
   exact id_le_iterate_of_id_le le_succ n a
 #align exists_succ_iterate_iff_le exists_succ_iterate_iff_le
--/
 
-#print Succ.rec /-
+/- warning: succ.rec -> Succ.rec is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) m n) -> (P n) -> (P (Order.succ.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) m n) -> (P n))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) m n) -> (P n) -> (P (Order.succ.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) m n) -> (P n))
+Case conversion may be inaccurate. Consider using '#align succ.rec Succ.recₓ'. -/
 /-- Induction principle on a type with a `succ_order` for all elements above a given element `m`. -/
 @[elab_as_elim]
 theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n → P n → P (succ n)) ⦃n : α⦄
@@ -1817,15 +2386,18 @@ theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n →
   · rw [Function.iterate_succ_apply']
     exact h1 _ (id_le_iterate_of_id_le le_succ n m) ih
 #align succ.rec Succ.rec
--/
 
-#print Succ.rec_iff /-
+/- warning: succ.rec_iff -> Succ.rec_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.succ.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.succ.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
+Case conversion may be inaccurate. Consider using '#align succ.rec_iff Succ.rec_iffₓ'. -/
 theorem Succ.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (succ a)) {a b : α} (h : a ≤ b) :
     p a ↔ p b := by
   obtain ⟨n, rfl⟩ := h.exists_succ_iterate
   exact iterate.rec (fun b => p a ↔ p b) (fun c hc => hc.trans (hsucc _)) Iff.rfl n
 #align succ.rec_iff Succ.rec_iff
--/
 
 end SuccOrder
 
@@ -1836,33 +2408,49 @@ variable [PredOrder α] [IsPredArchimedean α] {a b : α}
 instance : IsSuccArchimedean αᵒᵈ :=
   ⟨fun a b h => by convert exists_pred_iterate_of_le h.of_dual⟩
 
-#print LE.le.exists_pred_iterate /-
+/- warning: has_le.le.exists_pred_iterate -> LE.le.exists_pred_iterate is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a))
+Case conversion may be inaccurate. Consider using '#align has_le.le.exists_pred_iterate LE.le.exists_pred_iterateₓ'. -/
 theorem LE.le.exists_pred_iterate (h : a ≤ b) : ∃ n, (pred^[n]) b = a :=
   exists_pred_iterate_of_le h
 #align has_le.le.exists_pred_iterate LE.le.exists_pred_iterate
--/
 
-#print exists_pred_iterate_iff_le /-
+/- warning: exists_pred_iterate_iff_le -> exists_pred_iterate_iff_le is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a)) (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {a : α} {b : α}, Iff (Exists.{1} Nat (fun (n : Nat) => Eq.{succ u1} α (Nat.iterate.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2) n b) a)) (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b)
+Case conversion may be inaccurate. Consider using '#align exists_pred_iterate_iff_le exists_pred_iterate_iff_leₓ'. -/
 theorem exists_pred_iterate_iff_le : (∃ n, (pred^[n]) b = a) ↔ a ≤ b :=
   @exists_succ_iterate_iff_le αᵒᵈ _ _ _ _ _
 #align exists_pred_iterate_iff_le exists_pred_iterate_iff_le
--/
 
-#print Pred.rec /-
+/- warning: pred.rec -> Pred.rec is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) n m) -> (P n) -> (P (Order.pred.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) n m) -> (P n))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {P : α -> Prop} {m : α}, (P m) -> (forall (n : α), (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) n m) -> (P n) -> (P (Order.pred.{u1} α _inst_1 _inst_2 n))) -> (forall {{n : α}}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) n m) -> (P n))
+Case conversion may be inaccurate. Consider using '#align pred.rec Pred.recₓ'. -/
 /-- Induction principle on a type with a `pred_order` for all elements below a given element `m`. -/
 @[elab_as_elim]
 theorem Pred.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, n ≤ m → P n → P (pred n)) ⦃n : α⦄
     (hmn : n ≤ m) : P n :=
   @Succ.rec αᵒᵈ _ _ _ _ _ h0 h1 _ hmn
 #align pred.rec Pred.rec
--/
 
-#print Pred.rec_iff /-
+/- warning: pred.rec_iff -> Pred.rec_iff is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.pred.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] {p : α -> Prop}, (forall (a : α), Iff (p a) (p (Order.pred.{u1} α _inst_1 _inst_2 a))) -> (forall {a : α} {b : α}, (LE.le.{u1} α (Preorder.toLE.{u1} α _inst_1) a b) -> (Iff (p a) (p b)))
+Case conversion may be inaccurate. Consider using '#align pred.rec_iff Pred.rec_iffₓ'. -/
 theorem Pred.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) {a b : α} (h : a ≤ b) :
     p a ↔ p b :=
   (@Succ.rec_iff αᵒᵈ _ _ _ _ hsucc _ _ h).symm
 #align pred.rec_iff Pred.rec_iff
--/
 
 end PredOrder
 
@@ -1914,7 +2502,12 @@ section IsWellOrder
 
 variable [LinearOrder α]
 
-#print IsWellOrder.toIsPredArchimedean /-
+/- warning: is_well_order.to_is_pred_archimedean -> IsWellOrder.toIsPredArchimedean is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))], IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) _inst_2
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.SuccPred.Basic._hyg.11728 : α) (x._@.Mathlib.Order.SuccPred.Basic._hyg.11730 : α) => LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Order.SuccPred.Basic._hyg.11728 x._@.Mathlib.Order.SuccPred.Basic._hyg.11730)] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))], IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2
+Case conversion may be inaccurate. Consider using '#align is_well_order.to_is_pred_archimedean IsWellOrder.toIsPredArchimedeanₓ'. -/
 instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (· < ·)]
     [PredOrder α] : IsPredArchimedean α :=
   ⟨fun a => by
@@ -1928,13 +2521,16 @@ instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (
     refine' ⟨k + 1, _⟩
     rw [iterate_add_apply, iterate_one, hk]⟩
 #align is_well_order.to_is_pred_archimedean IsWellOrder.toIsPredArchimedean
--/
 
-#print IsWellOrder.toIsSuccArchimedean /-
+/- warning: is_well_order.to_is_succ_archimedean -> IsWellOrder.toIsSuccArchimedean is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (GT.gt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))))] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1))))], IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (LinearOrder.toLattice.{u1} α _inst_1)))) _inst_2
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : LinearOrder.{u1} α] [h : IsWellOrder.{u1} α (fun (x._@.Mathlib.Order.SuccPred.Basic._hyg.11899 : α) (x._@.Mathlib.Order.SuccPred.Basic._hyg.11901 : α) => GT.gt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))) x._@.Mathlib.Order.SuccPred.Basic._hyg.11899 x._@.Mathlib.Order.SuccPred.Basic._hyg.11901)] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1)))))], IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α (SemilatticeInf.toPartialOrder.{u1} α (Lattice.toSemilatticeInf.{u1} α (DistribLattice.toLattice.{u1} α (instDistribLattice.{u1} α _inst_1))))) _inst_2
+Case conversion may be inaccurate. Consider using '#align is_well_order.to_is_succ_archimedean IsWellOrder.toIsSuccArchimedeanₓ'. -/
 instance (priority := 100) IsWellOrder.toIsSuccArchimedean [h : IsWellOrder α (· > ·)]
     [SuccOrder α] : IsSuccArchimedean α := by convert@OrderDual.isSuccArchimedean αᵒᵈ _ _ _
 #align is_well_order.to_is_succ_archimedean IsWellOrder.toIsSuccArchimedean
--/
 
 end IsWellOrder
 
@@ -1944,7 +2540,7 @@ variable [Preorder α] [OrderBot α] [SuccOrder α] [IsSuccArchimedean α]
 
 /- warning: succ.rec_bot -> Succ.rec_bot is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] [_inst_4 : IsSuccArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.succ.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] [_inst_4 : IsSuccArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.succ.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] [_inst_4 : IsSuccArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.succ.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
 Case conversion may be inaccurate. Consider using '#align succ.rec_bot Succ.rec_botₓ'. -/
@@ -1960,7 +2556,7 @@ variable [Preorder α] [OrderTop α] [PredOrder α] [IsPredArchimedean α]
 
 /- warning: pred.rec_top -> Pred.rec_top is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] [_inst_4 : IsPredArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.pred.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] [_inst_4 : IsPredArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toHasLe.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.pred.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] [_inst_4 : IsPredArchimedean.{u1} α _inst_1 _inst_3] (p : α -> Prop), (p (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) -> (forall (a : α), (p a) -> (p (Order.pred.{u1} α _inst_1 _inst_3 a))) -> (forall (a : α), p a)
 Case conversion may be inaccurate. Consider using '#align pred.rec_top Pred.rec_topₓ'. -/

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

@@ -736,20 +736,20 @@ section CompleteLattice
 
 variable [CompleteLattice α] [SuccOrder α]
 
-/- warning: order.succ_eq_infi -> Order.succ_eq_infᵢ is a dubious translation:
+/- warning: order.succ_eq_infi -> Order.succ_eq_iInf is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (infᵢ.{u1, succ u1} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) α (fun (b : α) => infᵢ.{u1, 0} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
+  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iInf.{u1, succ u1} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) α (fun (b : α) => iInf.{u1, 0} α (CompleteSemilatticeInf.toHasInf.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (infᵢ.{u1, succ u1} α (CompleteLattice.toInfSet.{u1} α _inst_1) α (fun (b : α) => infᵢ.{u1, 0} α (CompleteLattice.toInfSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
-Case conversion may be inaccurate. Consider using '#align order.succ_eq_infi Order.succ_eq_infᵢₓ'. -/
-theorem succ_eq_infᵢ (a : α) : succ a = ⨅ (b) (h : a < b), b :=
+  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iInf.{u1, succ u1} α (CompleteLattice.toInfSet.{u1} α _inst_1) α (fun (b : α) => iInf.{u1, 0} α (CompleteLattice.toInfSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) a b) => b)))
+Case conversion may be inaccurate. Consider using '#align order.succ_eq_infi Order.succ_eq_iInfₓ'. -/
+theorem succ_eq_iInf (a : α) : succ a = ⨅ (b) (h : a < b), b :=
   by
-  refine' le_antisymm (le_infᵢ fun b => le_infᵢ succ_le_of_lt) _
+  refine' le_antisymm (le_iInf fun b => le_iInf succ_le_of_lt) _
   obtain rfl | ha := eq_or_ne a ⊤
   · rw [succ_top]
     exact le_top
-  exact infᵢ₂_le _ (lt_succ_iff_ne_top.2 ha)
-#align order.succ_eq_infi Order.succ_eq_infᵢ
+  exact iInf₂_le _ (lt_succ_iff_ne_top.2 ha)
+#align order.succ_eq_infi Order.succ_eq_iInf
 
 end CompleteLattice
 
@@ -1245,20 +1245,20 @@ section CompleteLattice
 
 variable [CompleteLattice α] [PredOrder α]
 
-/- warning: order.pred_eq_supr -> Order.pred_eq_supᵢ is a dubious translation:
+/- warning: order.pred_eq_supr -> Order.pred_eq_iSup is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (supᵢ.{u1, succ u1} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) α (fun (b : α) => supᵢ.{u1, 0} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
+  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iSup.{u1, succ u1} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) α (fun (b : α) => iSup.{u1, 0} α (CompleteSemilatticeSup.toHasSup.{u1} α (CompleteLattice.toCompleteSemilatticeSup.{u1} α _inst_1)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (supᵢ.{u1, succ u1} α (CompleteLattice.toSupSet.{u1} α _inst_1) α (fun (b : α) => supᵢ.{u1, 0} α (CompleteLattice.toSupSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
-Case conversion may be inaccurate. Consider using '#align order.pred_eq_supr Order.pred_eq_supᵢₓ'. -/
-theorem pred_eq_supᵢ (a : α) : pred a = ⨆ (b) (h : b < a), b :=
+  forall {α : Type.{u1}} [_inst_1 : CompleteLattice.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))] (a : α), Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1))) _inst_2 a) (iSup.{u1, succ u1} α (CompleteLattice.toSupSet.{u1} α _inst_1) α (fun (b : α) => iSup.{u1, 0} α (CompleteLattice.toSupSet.{u1} α _inst_1) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) (fun (h : LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α (CompleteSemilatticeInf.toPartialOrder.{u1} α (CompleteLattice.toCompleteSemilatticeInf.{u1} α _inst_1)))) b a) => b)))
+Case conversion may be inaccurate. Consider using '#align order.pred_eq_supr Order.pred_eq_iSupₓ'. -/
+theorem pred_eq_iSup (a : α) : pred a = ⨆ (b) (h : b < a), b :=
   by
-  refine' le_antisymm _ (supᵢ_le fun b => supᵢ_le le_pred_of_lt)
+  refine' le_antisymm _ (iSup_le fun b => iSup_le le_pred_of_lt)
   obtain rfl | ha := eq_or_ne a ⊥
   · rw [pred_bot]
     exact bot_le
-  · exact @le_supᵢ₂ _ _ (fun b => b < a) _ (fun a _ => a) (pred a) (pred_lt_iff_ne_bot.2 ha)
-#align order.pred_eq_supr Order.pred_eq_supᵢ
+  · exact @le_iSup₂ _ _ (fun b => b < a) _ (fun a _ => a) (pred a) (pred_lt_iff_ne_bot.2 ha)
+#align order.pred_eq_supr Order.pred_eq_iSup
 
 end CompleteLattice
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/2651125b48fc5c170ab1111afd0817c903b1fc6c

@@ -507,19 +507,19 @@ theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a :=
 #align order.le_le_succ_iff Order.le_le_succ_iff
 -/
 
-#print Order.Covby.succ_eq /-
-theorem Order.Covby.succ_eq (h : a ⋖ b) : succ a = b :=
+#print Covby.succ_eq /-
+theorem Covby.succ_eq (h : a ⋖ b) : succ a = b :=
   (succ_le_of_lt h.lt).eq_of_not_lt fun h' => h.2 (lt_succ_of_not_isMax h.lt.not_isMax) h'
-#align covby.succ_eq Order.Covby.succ_eq
+#align covby.succ_eq Covby.succ_eq
 -/
 
-#print Order.Wcovby.le_succ /-
-theorem Order.Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a :=
+#print Wcovby.le_succ /-
+theorem Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.succ_eq.ge
   · exact le_succ _
-#align wcovby.le_succ Order.Wcovby.le_succ
+#align wcovby.le_succ Wcovby.le_succ
 -/
 
 #print Order.le_succ_iff_eq_or_le /-
@@ -610,7 +610,7 @@ theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b :=
 theorem succ_eq_iff_covby : succ a = b ↔ a ⋖ b :=
   ⟨by
     rintro rfl
-    exact covby_succ _, Order.Covby.succ_eq⟩
+    exact covby_succ _, Covby.succ_eq⟩
 #align order.succ_eq_iff_covby Order.succ_eq_iff_covby
 -/
 
@@ -730,7 +730,7 @@ instance [PartialOrder α] : Subsingleton (SuccOrder α) :=
     ext a
     by_cases ha : IsMax a
     · exact (@IsMax.succ_eq _ _ h₀ _ ha).trans ha.succ_eq.symm
-    · exact @Order.Covby.succ_eq _ _ h₀ _ _ (covby_succ_of_not_is_max ha)⟩
+    · exact @Covby.succ_eq _ _ h₀ _ _ (covby_succ_of_not_is_max ha)⟩
 
 section CompleteLattice
 
@@ -1027,19 +1027,19 @@ theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = p
 #align order.pred_le_le_iff Order.pred_le_le_iff
 -/
 
-#print Order.Covby.pred_eq /-
-theorem Order.Covby.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
+#print Covby.pred_eq /-
+theorem Covby.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
   (le_pred_of_lt h.lt).eq_of_not_gt fun h' => h.2 h' <| pred_lt_of_not_isMin h.lt.not_isMin
-#align covby.pred_eq Order.Covby.pred_eq
+#align covby.pred_eq Covby.pred_eq
 -/
 
-#print Order.Wcovby.pred_le /-
-theorem Order.Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a :=
+#print Wcovby.pred_le /-
+theorem Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a :=
   by
   obtain h | rfl := h.covby_or_eq
   · exact h.pred_eq.le
   · exact pred_le _
-#align wcovby.pred_le Order.Wcovby.pred_le
+#align wcovby.pred_le Wcovby.pred_le
 -/
 
 #print Order.pred_le_iff_eq_or_le /-
@@ -1118,7 +1118,7 @@ theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b :=
 theorem pred_eq_iff_covby : pred b = a ↔ a ⋖ b :=
   ⟨by
     rintro rfl
-    exact pred_covby _, Order.Covby.pred_eq⟩
+    exact pred_covby _, Covby.pred_eq⟩
 #align order.pred_eq_iff_covby Order.pred_eq_iff_covby
 -/
 
@@ -1239,7 +1239,7 @@ instance [PartialOrder α] : Subsingleton (PredOrder α) :=
     ext a
     by_cases ha : IsMin a
     · exact (@IsMin.pred_eq _ _ h₀ _ ha).trans ha.pred_eq.symm
-    · exact @Order.Covby.pred_eq _ _ h₀ _ _ (pred_covby_of_not_is_min ha)⟩
+    · exact @Covby.pred_eq _ _ h₀ _ _ (pred_covby_of_not_is_min ha)⟩
 
 section CompleteLattice
 

mathlib commit https://github.com/leanprover-community/mathlib/commit/347636a7a80595d55bedf6e6fbd996a3c39da69a

@@ -1478,7 +1478,7 @@ theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (WithTop.pred_top.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (WithTop.pred_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Order.pred.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) Std.Logic._auxLemma.4)) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))) Std.Logic._auxLemma.4)) a ha))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) not_false_eq_true)) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))) not_false_eq_true)) a ha))
 Case conversion may be inaccurate. Consider using '#align with_top.pred_untop WithTop.pred_untopₓ'. -/
 @[simp]
 theorem pred_untop :
@@ -1611,7 +1611,7 @@ theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
 lean 3 declaration is
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (WithBot.succ_bot.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (WithBot.succ_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Order.succ.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
 but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) Std.Logic._auxLemma.4)) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))) Std.Logic._auxLemma.4)) a ha))
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) not_false_eq_true)) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))) not_false_eq_true)) a ha))
 Case conversion may be inaccurate. Consider using '#align with_bot.succ_unbot WithBot.succ_unbotₓ'. -/
 @[simp]
 theorem succ_unbot :

mathlib commit https://github.com/leanprover-community/mathlib/commit/02ba8949f486ebecf93fe7460f1ed0564b5e442c

@@ -1474,6 +1474,12 @@ theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
 #align with_top.pred_coe WithTop.pred_coe
 -/
 
+/- warning: with_top.pred_untop -> WithTop.pred_untop is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (WithTop.pred_top.{u1} α _inst_1 _inst_2 _inst_3) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Top.top.{u1} α (OrderTop.toHasTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Ne.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (Not (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : WithTop.{u1} α) (a_1 : WithTop.{u1} α) (e_1 : Eq.{succ u1} (WithTop.{u1} α) a a_1) (b : WithTop.{u1} α) (b_1 : WithTop.{u1} α) (e_2 : Eq.{succ u1} (WithTop.{u1} α) b b_1) => congr.{succ u1, 1} (WithTop.{u1} α) Prop (Ne.{succ u1} (WithTop.{u1} α) a) (Ne.{succ u1} (WithTop.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithTop.{u1} α) ((WithTop.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithTop.{u1} α)) e_1) e_2) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.predOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (WithTop.pred_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)) (rfl.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) (Ne.def.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False (propext (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithTop.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithTop.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithTop.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithTop.{u1} α) (WithTop.hasCoeT.{u1} α))) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.hasTop.{u1} α))) (WithTop.coe_ne_top.{u1} α a)) α (Order.pred.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderTop.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : PredOrder.{u1} α _inst_1] (a : WithTop.{u1} α) (ha : Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))), Eq.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_3 (WithTop.untop.{u1} α a ha)) (WithTop.untop.{u1} α (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithTop.recTopCoe.{u1, 0} α (fun (a : WithTop.{u1} α) => (Ne.{succ u1} (WithTop.{u1} α) a (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) -> (Ne.{succ u1} (WithTop.{u1} α) (Order.pred.{u1} (WithTop.{u1} α) (WithTop.preorder.{u1} α _inst_1) (WithTop.instPredOrderWithTopPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (fun (ha : Ne.{succ u1} (WithTop.{u1} α) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) Std.Logic._auxLemma.4)) (fun (a : α) (ha : Ne.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α a) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithTop.{u1} α) (WithTop.some.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a)) (Top.top.{u1} (WithTop.{u1} α) (WithTop.top.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.22.{u1} α (Order.pred.{u1} α _inst_1 _inst_3 a))) Std.Logic._auxLemma.4)) a ha))
+Case conversion may be inaccurate. Consider using '#align with_top.pred_untop WithTop.pred_untopₓ'. -/
 @[simp]
 theorem pred_untop :
     ∀ (a : WithTop α) (ha : a ≠ ⊤),
@@ -1601,6 +1607,12 @@ theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
 #align with_bot.succ_coe WithBot.succ_coe
 -/
 
+/- warning: with_bot.succ_unbot -> WithBot.succ_unbot is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (WithBot.succ_bot.{u1} α _inst_1 _inst_2 _inst_3) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Bot.bot.{u1} α (OrderBot.toHasBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))))) (propext (Not False) True not_false_iff))) trivial) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) => Eq.mpr.{0} (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True (id_tag Tactic.IdTag.simp (Eq.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) True) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not False) True (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Not False) (Eq.trans.{1} Prop (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Ne.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (Not (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : WithBot.{u1} α) (a_1 : WithBot.{u1} α) (e_1 : Eq.{succ u1} (WithBot.{u1} α) a a_1) (b : WithBot.{u1} α) (b_1 : WithBot.{u1} α) (e_2 : Eq.{succ u1} (WithBot.{u1} α) b b_1) => congr.{succ u1, 1} (WithBot.{u1} α) Prop (Ne.{succ u1} (WithBot.{u1} α) a) (Ne.{succ u1} (WithBot.{u1} α) a_1) b b_1 (congr_arg.{succ u1, succ u1} (WithBot.{u1} α) ((WithBot.{u1} α) -> Prop) a a_1 (Ne.{succ u1} (WithBot.{u1} α)) e_1) e_2) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.succOrder.{u1} α _inst_1 _inst_2 _inst_3) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a)) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (WithBot.succ_coe.{u1} α _inst_1 _inst_2 _inst_3 a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)) (rfl.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) (Ne.def.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α)))) ((fun (a : Prop) (a_1 : Prop) (e_1 : Eq.{1} Prop a a_1) => congr_arg.{1, 1} Prop Prop a a_1 Not e_1) (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False (propext (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) False ((fun {α : Type.{u1}} {a : α} => iff_false_intro (Eq.{succ u1} (WithBot.{u1} α) ((fun (a : Type.{u1}) (b : Type.{u1}) [self : HasLiftT.{succ u1, succ u1} a b] => self.0) α (WithBot.{u1} α) (HasLiftT.mk.{succ u1, succ u1} α (WithBot.{u1} α) (CoeTCₓ.coe.{succ u1, succ u1} α (WithBot.{u1} α) (WithBot.hasCoeT.{u1} α))) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.hasBot.{u1} α))) (WithBot.coe_ne_bot.{u1} α a)) α (Order.succ.{u1} α _inst_1 _inst_3 a))))) (propext (Not False) True not_false_iff))) trivial) a ha))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] [_inst_2 : OrderBot.{u1} α (Preorder.toLE.{u1} α _inst_1)] [_inst_3 : SuccOrder.{u1} α _inst_1] (a : WithBot.{u1} α) (ha : Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))), Eq.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_3 (WithBot.unbot.{u1} α a ha)) (WithBot.unbot.{u1} α (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (WithBot.recBotCoe.{u1, 0} α (fun (a : WithBot.{u1} α) => (Ne.{succ u1} (WithBot.{u1} α) a (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) -> (Ne.{succ u1} (WithBot.{u1} α) (Order.succ.{u1} (WithBot.{u1} α) (WithBot.preorder.{u1} α _inst_1) (WithBot.instSuccOrderWithBotPreorder.{u1} α _inst_1 _inst_2 _inst_3) a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (fun (ha : Ne.{succ u1} (WithBot.{u1} α) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2)))) Std.Logic._auxLemma.4)) (fun (a : α) (ha : Ne.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α a) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) => of_eq_true (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Eq.trans.{1} Prop (Not (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α)))) (Not False) True (congrArg.{1, 1} Prop Prop (Eq.{succ u1} (WithBot.{u1} α) (WithBot.some.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a)) (Bot.bot.{u1} (WithBot.{u1} α) (WithBot.bot.{u1} α))) False Not (Mathlib.Order.WithBot._auxLemma.3.{u1} α (Order.succ.{u1} α _inst_1 _inst_3 a))) Std.Logic._auxLemma.4)) a ha))
+Case conversion may be inaccurate. Consider using '#align with_bot.succ_unbot WithBot.succ_unbotₓ'. -/
 @[simp]
 theorem succ_unbot :
     ∀ (a : WithBot α) (ha : a ≠ ⊥),

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

@@ -1920,7 +1920,7 @@ instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (
 
 #print IsWellOrder.toIsSuccArchimedean /-
 instance (priority := 100) IsWellOrder.toIsSuccArchimedean [h : IsWellOrder α (· > ·)]
-    [SuccOrder α] : IsSuccArchimedean α := by convert @OrderDual.isSuccArchimedean αᵒᵈ _ _ _
+    [SuccOrder α] : IsSuccArchimedean α := by convert@OrderDual.isSuccArchimedean αᵒᵈ _ _ _
 #align is_well_order.to_is_succ_archimedean IsWellOrder.toIsSuccArchimedean
 -/
 

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

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Yaël Dillies
 
 ! This file was ported from Lean 3 source module order.succ_pred.basic
-! leanprover-community/mathlib commit c3291da49cfa65f0d43b094750541c0731edc932
+! leanprover-community/mathlib commit 0111834459f5d7400215223ea95ae38a1265a907
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -1474,6 +1474,14 @@ theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) :=
 #align with_top.pred_coe WithTop.pred_coe
 -/
 
+@[simp]
+theorem pred_untop :
+    ∀ (a : WithTop α) (ha : a ≠ ⊤),
+      pred (a.untop ha) = (pred a).untop (by induction a using WithTop.recTopCoe <;> simp)
+  | ⊤, ha => (ha rfl).elim
+  | (a : α), ha => rfl
+#align with_top.pred_untop WithTop.pred_untop
+
 end Pred
 
 /-! #### Adding a `⊤` to a `no_max_order` -/
@@ -1593,6 +1601,14 @@ theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) :=
 #align with_bot.succ_coe WithBot.succ_coe
 -/
 
+@[simp]
+theorem succ_unbot :
+    ∀ (a : WithBot α) (ha : a ≠ ⊥),
+      succ (a.unbot ha) = (succ a).unbot (by induction a using WithBot.recBotCoe <;> simp)
+  | ⊥, ha => (ha rfl).elim
+  | (a : α), ha => rfl
+#align with_bot.succ_unbot WithBot.succ_unbot
+
 end Succ
 
 section Pred

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

Co-authored-by: Ruben Van de Velde <65514131+Ruben-VandeVelde@users.noreply.github.com>

@@ -281,7 +281,7 @@ theorem succ_mono : Monotone (succ : α → α) := fun _ _ => succ_le_succ
 #align order.succ_mono Order.succ_mono
 
 theorem le_succ_iterate (k : ℕ) (x : α) : x ≤ succ^[k] x := by
-  conv_lhs => rw [(by simp only [Function.iterate_id, id.def] : x = id^[k] x)]
+  conv_lhs => rw [(by simp only [Function.iterate_id, id] : x = id^[k] x)]
   exact Monotone.le_iterate_of_le succ_mono le_succ k x
 #align order.le_succ_iterate Order.le_succ_iterate
 
@@ -655,7 +655,7 @@ theorem pred_mono : Monotone (pred : α → α) := fun _ _ => pred_le_pred
 #align order.pred_mono Order.pred_mono
 
 theorem pred_iterate_le (k : ℕ) (x : α) : pred^[k] x ≤ x := by
-  conv_rhs => rw [(by simp only [Function.iterate_id, id.def] : x = id^[k] x)]
+  conv_rhs => rw [(by simp only [Function.iterate_id, id] : x = id^[k] x)]
   exact Monotone.iterate_le_of_le pred_mono pred_le k x
 #align order.pred_iterate_le Order.pred_iterate_le
 
@@ -966,7 +966,7 @@ theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
 theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax (succ^[n - 1] i)) :
     pred^[n] (succ^[n] i) = i := by
   induction' n with n hn
-  · simp only [Nat.zero_eq, Function.iterate_zero, id.def]
+  · simp only [Nat.zero_eq, Function.iterate_zero, id]
   rw [Nat.succ_sub_succ_eq_sub, Nat.sub_zero] at hin
   have h_not_max : ¬IsMax (succ^[n - 1] i) := by
     cases' n with n

Also do the same for "/-A". This is a purely aesthetic change (and exhaustive).

@@ -61,15 +61,15 @@ variable {α β : Type*}
 /-- Order equipped with a sensible successor function. -/
 @[ext]
 class SuccOrder (α : Type*) [Preorder α] where
-  /--Successor function-/
+  /-- Successor function-/
   succ : α → α
-  /--Proof of basic ordering with respect to `succ`-/
+  /-- Proof of basic ordering with respect to `succ`-/
   le_succ : ∀ a, a ≤ succ a
-  /--Proof of interaction between `succ` and maximal element-/
+  /-- Proof of interaction between `succ` and maximal element-/
   max_of_succ_le {a} : succ a ≤ a → IsMax a
-  /--Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
+  /-- Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
   succ_le_of_lt {a b} : a < b → succ a ≤ b
-  /--Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
+  /-- Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
   le_of_lt_succ {a b} : a < succ b → a ≤ b
 #align succ_order SuccOrder
 #align succ_order.ext_iff SuccOrder.ext_iff
@@ -78,15 +78,15 @@ class SuccOrder (α : Type*) [Preorder α] where
 /-- Order equipped with a sensible predecessor function. -/
 @[ext]
 class PredOrder (α : Type*) [Preorder α] where
-  /--Predecessor function-/
+  /-- Predecessor function-/
   pred : α → α
-  /--Proof of basic ordering with respect to `pred`-/
+  /-- Proof of basic ordering with respect to `pred`-/
   pred_le : ∀ a, pred a ≤ a
-  /--Proof of interaction between `pred` and minimal element-/
+  /-- Proof of interaction between `pred` and minimal element-/
   min_of_le_pred {a} : a ≤ pred a → IsMin a
-  /--Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
+  /-- Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
   le_pred_of_lt {a b} : a < b → a ≤ pred b
-  /--Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
+  /-- Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
   le_of_pred_lt {a b} : pred a < b → a ≤ b
 #align pred_order PredOrder
 #align pred_order.ext PredOrder.ext

Classifies by adding issue number #10618 to porting notes claiming "simp can prove it".

@@ -525,12 +525,12 @@ theorem succ_top : succ (⊤ : α) = ⊤ := by
   rw [succ_eq_iff_isMax, isMax_iff_eq_top]
 #align order.succ_top Order.succ_top
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem succ_le_iff_eq_top : succ a ≤ a ↔ a = ⊤ :=
   succ_le_iff_isMax.trans isMax_iff_eq_top
 #align order.succ_le_iff_eq_top Order.succ_le_iff_eq_top
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem lt_succ_iff_ne_top : a < succ a ↔ a ≠ ⊤ :=
   lt_succ_iff_not_isMax.trans not_isMax_iff_ne_top
 #align order.lt_succ_iff_ne_top Order.lt_succ_iff_ne_top
@@ -541,7 +541,7 @@ section OrderBot
 
 variable [OrderBot α]
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem lt_succ_bot_iff [NoMaxOrder α] : a < succ ⊥ ↔ a = ⊥ := by rw [lt_succ_iff, le_bot_iff]
 #align order.lt_succ_bot_iff Order.lt_succ_bot_iff
 
@@ -875,12 +875,12 @@ theorem pred_bot : pred (⊥ : α) = ⊥ :=
   isMin_bot.pred_eq
 #align order.pred_bot Order.pred_bot
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem le_pred_iff_eq_bot : a ≤ pred a ↔ a = ⊥ :=
   @succ_le_iff_eq_top αᵒᵈ _ _ _ _
 #align order.le_pred_iff_eq_bot Order.le_pred_iff_eq_bot
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem pred_lt_iff_ne_bot : pred a < a ↔ a ≠ ⊥ :=
   @lt_succ_iff_ne_top αᵒᵈ _ _ _ _
 #align order.pred_lt_iff_ne_bot Order.pred_lt_iff_ne_bot
@@ -891,7 +891,7 @@ section OrderTop
 
 variable [OrderTop α]
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem pred_top_lt_iff [NoMinOrder α] : pred ⊤ < a ↔ a = ⊤ :=
   @lt_succ_bot_iff αᵒᵈ _ _ _ _ _
 #align order.pred_top_lt_iff Order.pred_top_lt_iff
@@ -953,12 +953,12 @@ theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a :=
   CovBy.pred_eq (covBy_succ_of_not_isMax h)
 #align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMax
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a :=
   CovBy.succ_eq (pred_covBy _)
 #align order.succ_pred Order.succ_pred
 
--- Porting note: removing @[simp],`simp` can prove it
+-- Porting note (#10618): removing @[simp],`simp` can prove it
 theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
   CovBy.pred_eq (covBy_succ _)
 #align order.pred_succ Order.pred_succ

Per the style guidelines, λ is disallowed in mathlib. This is close to exhaustive; I left some tactic code alone when it seemed to me that tactic could be upstreamed soon.

Notes

• In lines I was modifying anyway, I also converted => to ↦.
• Also contains some mild in-passing indentation fixes in Mathlib/Order/SupClosed.
• Some doc comments still contained Lean 3 syntax λ x, , which I also replaced.

@@ -1485,16 +1485,16 @@ variable [Preorder α] [Nonempty α] [Preorder β] {f : α → β}
 lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchimedean β]
     (hf : StrictMono f) : ¬ BddAbove (Set.range f) := by
   rintro ⟨m, hm⟩
-  have hm' : ∀ a, f a ≤ m := λ a ↦ hm <| Set.mem_range_self _
+  have hm' : ∀ a, f a ≤ m := fun a ↦ hm <| Set.mem_range_self _
   obtain ⟨a₀⟩ := ‹Nonempty α›
   suffices ∀ b, f a₀ ≤ b → ∃ a, b < f a by
     obtain ⟨a, ha⟩ : ∃ a, m < f a := this m (hm' a₀)
     exact ha.not_le (hm' a)
-  have h : ∀ a, ∃ a', f a < f a' := λ a ↦ (exists_gt a).imp (λ a' h ↦ hf h)
+  have h : ∀ a, ∃ a', f a < f a' := fun a ↦ (exists_gt a).imp (fun a' h ↦ hf h)
   apply Succ.rec
   · exact h a₀
   rintro b _ ⟨a, hba⟩
-  exact (h a).imp (λ a' ↦ (succ_le_of_lt hba).trans_lt)
+  exact (h a).imp (fun a' ↦ (succ_le_of_lt hba).trans_lt)
 
 lemma StrictMono.not_bddBelow_range [NoMinOrder α] [PredOrder β] [IsPredArchimedean β]
     (hf : StrictMono f) : ¬ BddBelow (Set.range f) := hf.dual.not_bddAbove_range

Co-authored-by: Yaël Dillies <yael.dillies@gmail.com>

@@ -1442,8 +1442,12 @@ section LinearOrder
 variable [LinearOrder α]
 
 section SuccOrder
+variable [SuccOrder α]
 
-variable [SuccOrder α] [IsSuccArchimedean α] {a b : α}
+lemma succ_max (a b : α) : succ (max a b) = max (succ a) (succ b) := succ_mono.map_max
+lemma succ_min (a b : α) : succ (min a b) = min (succ a) (succ b) := succ_mono.map_min
+
+variable [IsSuccArchimedean α] {a b : α}
 
 theorem exists_succ_iterate_or : (∃ n, succ^[n] a = b) ∨ ∃ n, succ^[n] b = a :=
   (le_total a b).imp exists_succ_iterate_of_le exists_succ_iterate_of_le
@@ -1456,8 +1460,12 @@ theorem Succ.rec_linear {p : α → Prop} (hsucc : ∀ a, p a ↔ p (succ a)) (a
 end SuccOrder
 
 section PredOrder
+variable [PredOrder α]
 
-variable [PredOrder α] [IsPredArchimedean α] {a b : α}
+lemma pred_max (a b : α) : pred (max a b) = max (pred a) (pred b) := pred_mono.map_max
+lemma pred_min (a b : α) : pred (min a b) = min (pred a) (pred b) := pred_mono.map_min
+
+variable [IsPredArchimedean α] {a b : α}
 
 theorem exists_pred_iterate_or : (∃ n, pred^[n] b = a) ∨ ∃ n, pred^[n] a = b :=
   (le_total a b).imp exists_pred_iterate_of_le exists_pred_iterate_of_le

Homogenises porting notes via capitalisation and addition of whitespace.

It makes the following changes:

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

@@ -525,12 +525,12 @@ theorem succ_top : succ (⊤ : α) = ⊤ := by
   rw [succ_eq_iff_isMax, isMax_iff_eq_top]
 #align order.succ_top Order.succ_top
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem succ_le_iff_eq_top : succ a ≤ a ↔ a = ⊤ :=
   succ_le_iff_isMax.trans isMax_iff_eq_top
 #align order.succ_le_iff_eq_top Order.succ_le_iff_eq_top
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem lt_succ_iff_ne_top : a < succ a ↔ a ≠ ⊤ :=
   lt_succ_iff_not_isMax.trans not_isMax_iff_ne_top
 #align order.lt_succ_iff_ne_top Order.lt_succ_iff_ne_top
@@ -541,7 +541,7 @@ section OrderBot
 
 variable [OrderBot α]
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem lt_succ_bot_iff [NoMaxOrder α] : a < succ ⊥ ↔ a = ⊥ := by rw [lt_succ_iff, le_bot_iff]
 #align order.lt_succ_bot_iff Order.lt_succ_bot_iff
 
@@ -875,12 +875,12 @@ theorem pred_bot : pred (⊥ : α) = ⊥ :=
   isMin_bot.pred_eq
 #align order.pred_bot Order.pred_bot
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem le_pred_iff_eq_bot : a ≤ pred a ↔ a = ⊥ :=
   @succ_le_iff_eq_top αᵒᵈ _ _ _ _
 #align order.le_pred_iff_eq_bot Order.le_pred_iff_eq_bot
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem pred_lt_iff_ne_bot : pred a < a ↔ a ≠ ⊥ :=
   @lt_succ_iff_ne_top αᵒᵈ _ _ _ _
 #align order.pred_lt_iff_ne_bot Order.pred_lt_iff_ne_bot
@@ -891,7 +891,7 @@ section OrderTop
 
 variable [OrderTop α]
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem pred_top_lt_iff [NoMinOrder α] : pred ⊤ < a ↔ a = ⊤ :=
   @lt_succ_bot_iff αᵒᵈ _ _ _ _ _
 #align order.pred_top_lt_iff Order.pred_top_lt_iff
@@ -953,12 +953,12 @@ theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a :=
   CovBy.pred_eq (covBy_succ_of_not_isMax h)
 #align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMax
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a :=
   CovBy.succ_eq (pred_covBy _)
 #align order.succ_pred Order.succ_pred
 
---Porting note: removing @[simp],`simp` can prove it
+-- Porting note: removing @[simp],`simp` can prove it
 theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
   CovBy.pred_eq (covBy_succ _)
 #align order.pred_succ Order.pred_succ

Rename

• Covby → CovBy, Wcovby → WCovBy
• *covby* → *covBy*
• wcovby.finset_val → WCovBy.finset_val, wcovby.finset_coe → WCovBy.finset_coe
• Covby.is_coatom → CovBy.isCoatom

@@ -50,7 +50,7 @@ Is `GaloisConnection pred succ` always true? If not, we should introduce
 class SuccPredOrder (α : Type*) [Preorder α] extends SuccOrder α, PredOrder α :=
   (pred_succ_gc : GaloisConnection (pred : α → α) succ)
 ```
-`Covby` should help here.
+`CovBy` should help here.
 -/
 
 
@@ -239,13 +239,13 @@ theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a :=
 alias ⟨_, lt_succ_of_not_isMax⟩ := lt_succ_iff_not_isMax
 #align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMax
 
-theorem wcovby_succ (a : α) : a ⩿ succ a :=
+theorem wcovBy_succ (a : α) : a ⩿ succ a :=
   ⟨le_succ a, fun _ hb => (succ_le_of_lt hb).not_lt⟩
-#align order.wcovby_succ Order.wcovby_succ
+#align order.wcovby_succ Order.wcovBy_succ
 
-theorem covby_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a :=
-  (wcovby_succ a).covby_of_lt <| lt_succ_of_not_isMax h
-#align order.covby_succ_of_not_is_max Order.covby_succ_of_not_isMax
+theorem covBy_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a :=
+  (wcovBy_succ a).covBy_of_lt <| lt_succ_of_not_isMax h
+#align order.covby_succ_of_not_is_max Order.covBy_succ_of_not_isMax
 
 theorem lt_succ_iff_of_not_isMax (ha : ¬IsMax a) : b < succ a ↔ b ≤ a :=
   ⟨le_of_lt_succ, fun h => h.trans_lt <| lt_succ_of_not_isMax ha⟩
@@ -360,9 +360,9 @@ alias ⟨lt_of_succ_lt_succ, succ_lt_succ⟩ := succ_lt_succ_iff
 theorem succ_strictMono : StrictMono (succ : α → α) := fun _ _ => succ_lt_succ
 #align order.succ_strict_mono Order.succ_strictMono
 
-theorem covby_succ (a : α) : a ⋖ succ a :=
-  covby_succ_of_not_isMax <| not_isMax a
-#align order.covby_succ Order.covby_succ
+theorem covBy_succ (a : α) : a ⋖ succ a :=
+  covBy_succ_of_not_isMax <| not_isMax a
+#align order.covby_succ Order.covBy_succ
 
 @[simp]
 theorem Iio_succ (a : α) : Iio (succ a) = Iic a :=
@@ -427,15 +427,15 @@ theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a := by
   · exact ⟨le_succ a, le_rfl⟩
 #align order.le_le_succ_iff Order.le_le_succ_iff
 
-theorem _root_.Covby.succ_eq (h : a ⋖ b) : succ a = b :=
+theorem _root_.CovBy.succ_eq (h : a ⋖ b) : succ a = b :=
   (succ_le_of_lt h.lt).eq_of_not_lt fun h' => h.2 (lt_succ_of_not_isMax h.lt.not_isMax) h'
-#align covby.succ_eq Covby.succ_eq
+#align covby.succ_eq CovBy.succ_eq
 
-theorem _root_.Wcovby.le_succ (h : a ⩿ b) : b ≤ succ a := by
-  obtain h | rfl := h.covby_or_eq
-  · exact (Covby.succ_eq h).ge
+theorem _root_.WCovBy.le_succ (h : a ⩿ b) : b ≤ succ a := by
+  obtain h | rfl := h.covBy_or_eq
+  · exact (CovBy.succ_eq h).ge
   · exact le_succ _
-#align wcovby.le_succ Wcovby.le_succ
+#align wcovby.le_succ WCovBy.le_succ
 
 theorem le_succ_iff_eq_or_le : a ≤ succ b ↔ a = succ b ∨ a ≤ b := by
   by_cases hb : IsMax b
@@ -496,11 +496,11 @@ theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b :=
   lt_succ_iff.trans le_iff_eq_or_lt
 #align order.lt_succ_iff_eq_or_lt Order.lt_succ_iff_eq_or_lt
 
-theorem succ_eq_iff_covby : succ a = b ↔ a ⋖ b :=
+theorem succ_eq_iff_covBy : succ a = b ↔ a ⋖ b :=
   ⟨by
     rintro rfl
-    exact covby_succ _, Covby.succ_eq⟩
-#align order.succ_eq_iff_covby Order.succ_eq_iff_covby
+    exact covBy_succ _, CovBy.succ_eq⟩
+#align order.succ_eq_iff_covby Order.succ_eq_iff_covBy
 
 theorem Iio_succ_eq_insert (a : α) : Iio (succ a) = insert a (Iio a) :=
   Iio_succ_eq_insert_of_not_isMax <| not_isMax a
@@ -570,7 +570,7 @@ instance [PartialOrder α] : Subsingleton (SuccOrder α) :=
     ext a
     by_cases ha : IsMax a
     · exact (@IsMax.succ_eq _ _ h₀ _ ha).trans ha.succ_eq.symm
-    · exact @Covby.succ_eq _ _ h₀ _ _ (covby_succ_of_not_isMax ha)⟩
+    · exact @CovBy.succ_eq _ _ h₀ _ _ (covBy_succ_of_not_isMax ha)⟩
 
 section CompleteLattice
 
@@ -627,13 +627,13 @@ theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a :=
 alias ⟨_, pred_lt_of_not_isMin⟩ := pred_lt_iff_not_isMin
 #align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMin
 
-theorem pred_wcovby (a : α) : pred a ⩿ a :=
+theorem pred_wcovBy (a : α) : pred a ⩿ a :=
   ⟨pred_le a, fun _ hb => (le_of_pred_lt hb).not_lt⟩
-#align order.pred_wcovby Order.pred_wcovby
+#align order.pred_wcovby Order.pred_wcovBy
 
-theorem pred_covby_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a :=
-  (pred_wcovby a).covby_of_lt <| pred_lt_of_not_isMin h
-#align order.pred_covby_of_not_is_min Order.pred_covby_of_not_isMin
+theorem pred_covBy_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a :=
+  (pred_wcovBy a).covBy_of_lt <| pred_lt_of_not_isMin h
+#align order.pred_covby_of_not_is_min Order.pred_covBy_of_not_isMin
 
 theorem pred_lt_iff_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a ≤ b :=
   ⟨le_of_pred_lt, (pred_lt_of_not_isMin ha).trans_le⟩
@@ -727,9 +727,9 @@ alias ⟨lt_of_pred_lt_pred, pred_lt_pred⟩ := pred_lt_pred_iff
 theorem pred_strictMono : StrictMono (pred : α → α) := fun _ _ => pred_lt_pred
 #align order.pred_strict_mono Order.pred_strictMono
 
-theorem pred_covby (a : α) : pred a ⋖ a :=
-  pred_covby_of_not_isMin <| not_isMin a
-#align order.pred_covby Order.pred_covby
+theorem pred_covBy (a : α) : pred a ⋖ a :=
+  pred_covBy_of_not_isMin <| not_isMin a
+#align order.pred_covby Order.pred_covBy
 
 @[simp]
 theorem Ioi_pred (a : α) : Ioi (pred a) = Ici a :=
@@ -786,15 +786,15 @@ theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = p
   · exact ⟨le_rfl, pred_le a⟩
 #align order.pred_le_le_iff Order.pred_le_le_iff
 
-theorem _root_.Covby.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
+theorem _root_.CovBy.pred_eq {a b : α} (h : a ⋖ b) : pred b = a :=
   (le_pred_of_lt h.lt).eq_of_not_gt fun h' => h.2 h' <| pred_lt_of_not_isMin h.lt.not_isMin
-#align covby.pred_eq Covby.pred_eq
+#align covby.pred_eq CovBy.pred_eq
 
-theorem _root_.Wcovby.pred_le (h : a ⩿ b) : pred b ≤ a := by
-  obtain h | rfl := h.covby_or_eq
-  · exact (Covby.pred_eq h).le
+theorem _root_.WCovBy.pred_le (h : a ⩿ b) : pred b ≤ a := by
+  obtain h | rfl := h.covBy_or_eq
+  · exact (CovBy.pred_eq h).le
   · exact pred_le _
-#align wcovby.pred_le Wcovby.pred_le
+#align wcovby.pred_le WCovBy.pred_le
 
 theorem pred_le_iff_eq_or_le : pred a ≤ b ↔ b = pred a ∨ a ≤ b := by
   by_cases ha : IsMin a
@@ -846,11 +846,11 @@ theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b :=
   pred_lt_iff.trans le_iff_eq_or_lt
 #align order.pred_lt_iff_eq_or_lt Order.pred_lt_iff_eq_or_lt
 
-theorem pred_eq_iff_covby : pred b = a ↔ a ⋖ b :=
+theorem pred_eq_iff_covBy : pred b = a ↔ a ⋖ b :=
   ⟨by
     rintro rfl
-    exact pred_covby _, Covby.pred_eq⟩
-#align order.pred_eq_iff_covby Order.pred_eq_iff_covby
+    exact pred_covBy _, CovBy.pred_eq⟩
+#align order.pred_eq_iff_covby Order.pred_eq_iff_covBy
 
 theorem Ioi_pred_eq_insert (a : α) : Ioi (pred a) = insert a (Ioi a) :=
   ext fun _ => pred_lt_iff_eq_or_lt.trans <| or_congr_left eq_comm
@@ -921,7 +921,7 @@ instance [PartialOrder α] : Subsingleton (PredOrder α) :=
     ext a
     by_cases ha : IsMin a
     · exact (@IsMin.pred_eq _ _ h₀ _ ha).trans ha.pred_eq.symm
-    · exact @Covby.pred_eq _ _ h₀ _ _ (pred_covby_of_not_isMin ha)⟩
+    · exact @CovBy.pred_eq _ _ h₀ _ _ (pred_covBy_of_not_isMin ha)⟩
 
 section CompleteLattice
 
@@ -945,22 +945,22 @@ variable [PartialOrder α] [SuccOrder α] [PredOrder α] {a b : α}
 
 @[simp]
 theorem succ_pred_of_not_isMin (h : ¬IsMin a) : succ (pred a) = a :=
-  Covby.succ_eq (pred_covby_of_not_isMin h)
+  CovBy.succ_eq (pred_covBy_of_not_isMin h)
 #align order.succ_pred_of_not_is_min Order.succ_pred_of_not_isMin
 
 @[simp]
 theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a :=
-  Covby.pred_eq (covby_succ_of_not_isMax h)
+  CovBy.pred_eq (covBy_succ_of_not_isMax h)
 #align order.pred_succ_of_not_is_max Order.pred_succ_of_not_isMax
 
 --Porting note: removing @[simp],`simp` can prove it
 theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a :=
-  Covby.succ_eq (pred_covby _)
+  CovBy.succ_eq (pred_covBy _)
 #align order.succ_pred Order.succ_pred
 
 --Porting note: removing @[simp],`simp` can prove it
 theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a :=
-  Covby.pred_eq (covby_succ _)
+  CovBy.pred_eq (covBy_succ _)
 #align order.pred_succ Order.pred_succ
 
 theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax (succ^[n - 1] i)) :

See Zulip thread for the discussion.

@@ -256,7 +256,7 @@ theorem succ_le_iff_of_not_isMax (ha : ¬IsMax a) : succ a ≤ b ↔ a < b :=
 #align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMax
 
 lemma succ_lt_succ_of_not_isMax (h : a < b) (hb : ¬ IsMax b) : succ a < succ b :=
-  (lt_succ_iff_of_not_isMax hb).2 $ succ_le_of_lt h
+  (lt_succ_iff_of_not_isMax hb).2 <| succ_le_of_lt h
 
 theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
     succ a < succ b ↔ a < b := by
@@ -644,7 +644,7 @@ theorem le_pred_iff_of_not_isMin (ha : ¬IsMin a) : b ≤ pred a ↔ b < a :=
 #align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMin
 
 lemma pred_lt_pred_of_not_isMin (h : a < b) (ha : ¬ IsMin a) : pred a < pred b :=
-  (pred_lt_iff_of_not_isMin ha).2 $ le_pred_of_lt h
+  (pred_lt_iff_of_not_isMin ha).2 <| le_pred_of_lt h
 
 @[simp, mono]
 theorem pred_le_pred {a b : α} (h : a ≤ b) : pred a ≤ pred b :=
@@ -1477,7 +1477,7 @@ variable [Preorder α] [Nonempty α] [Preorder β] {f : α → β}
 lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchimedean β]
     (hf : StrictMono f) : ¬ BddAbove (Set.range f) := by
   rintro ⟨m, hm⟩
-  have hm' : ∀ a, f a ≤ m := λ a ↦ hm $ Set.mem_range_self _
+  have hm' : ∀ a, f a ≤ m := λ a ↦ hm <| Set.mem_range_self _
   obtain ⟨a₀⟩ := ‹Nonempty α›
   suffices ∀ b, f a₀ ≤ b → ∃ a, b < f a by
     obtain ⟨a, ha⟩ : ∃ a, m < f a := this m (hm' a₀)

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

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

@@ -296,7 +296,7 @@ theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : succ^[n] a = succ^[m]
 
 theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : succ^[n] a = succ^[m] a)
     (h_ne : n ≠ m) : IsMax (succ^[n] a) := by
-  cases' le_total n m with h h
+  rcases le_total n m with h | h
   · exact isMax_iterate_succ_of_eq_of_lt h_eq (lt_of_le_of_ne h h_ne)
   · rw [h_eq]
     exact isMax_iterate_succ_of_eq_of_lt h_eq.symm (lt_of_le_of_ne h h_ne.symm)
@@ -1512,7 +1512,7 @@ instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (
     replace hab := eq_or_lt_of_le hab
     rcases hab with (rfl | hab)
     · exact ⟨0, rfl⟩
-    cases' le_or_lt b (pred b) with hb hb
+    rcases le_or_lt b (pred b) with hb | hb
     · cases (min_of_le_pred hb).not_lt hab
     dsimp at ih
     obtain ⟨k, hk⟩ := ih (pred b) hb (le_pred_of_lt hab)

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>

@@ -1418,7 +1418,7 @@ theorem LE.le.exists_pred_iterate (h : a ≤ b) : ∃ n, pred^[n] b = a :=
 #align has_le.le.exists_pred_iterate LE.le.exists_pred_iterate
 
 theorem exists_pred_iterate_iff_le : (∃ n, pred^[n] b = a) ↔ a ≤ b :=
-  @exists_succ_iterate_iff_le αᵒᵈ _ _ _ _ _
+  exists_succ_iterate_iff_le (α := αᵒᵈ)
 #align exists_pred_iterate_iff_le exists_pred_iterate_iff_le
 
 /-- Induction principle on a type with a `PredOrder` for all elements below a given element `m`. -/

Co-authored-by: Moritz Firsching <firsching@google.com>

@@ -1489,13 +1489,13 @@ lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchim
   exact (h a).imp (λ a' ↦ (succ_le_of_lt hba).trans_lt)
 
 lemma StrictMono.not_bddBelow_range [NoMinOrder α] [PredOrder β] [IsPredArchimedean β]
-  (hf : StrictMono f) : ¬ BddBelow (Set.range f) := hf.dual.not_bddAbove_range
+    (hf : StrictMono f) : ¬ BddBelow (Set.range f) := hf.dual.not_bddAbove_range
 
 lemma StrictAnti.not_bddAbove_range [NoMinOrder α] [SuccOrder β] [IsSuccArchimedean β]
-  (hf : StrictAnti f) : ¬ BddAbove (Set.range f) := hf.dual_right.not_bddBelow_range
+    (hf : StrictAnti f) : ¬ BddAbove (Set.range f) := hf.dual_right.not_bddBelow_range
 
 lemma StrictAnti.not_bddBelow_range [NoMaxOrder α] [PredOrder β] [IsPredArchimedean β]
-  (hf : StrictAnti f) : ¬ BddBelow (Set.range f) := hf.dual_right.not_bddAbove_range
+    (hf : StrictAnti f) : ¬ BddBelow (Set.range f) := hf.dual_right.not_bddAbove_range
 
 end bdd_range
 

@@ -256,14 +256,16 @@ theorem succ_le_iff_of_not_isMax (ha : ¬IsMax a) : succ a ≤ b ↔ a < b :=
 #align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMax
 
 lemma succ_lt_succ_of_not_isMax (h : a < b) (hb : ¬ IsMax b) : succ a < succ b :=
-(lt_succ_iff_of_not_isMax hb).2 $ succ_le_of_lt h
+  (lt_succ_iff_of_not_isMax hb).2 $ succ_le_of_lt h
 
-theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a < succ b ↔ a < b :=
-  by rw [lt_succ_iff_of_not_isMax hb, succ_le_iff_of_not_isMax ha]
+theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
+    succ a < succ b ↔ a < b := by
+  rw [lt_succ_iff_of_not_isMax hb, succ_le_iff_of_not_isMax ha]
 #align order.succ_lt_succ_iff_of_not_is_max Order.succ_lt_succ_iff_of_not_isMax
 
-theorem succ_le_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a ≤ succ b ↔ a ≤ b :=
-  by rw [succ_le_iff_of_not_isMax ha, lt_succ_iff_of_not_isMax hb]
+theorem succ_le_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
+    succ a ≤ succ b ↔ a ≤ b := by
+  rw [succ_le_iff_of_not_isMax ha, lt_succ_iff_of_not_isMax hb]
 #align order.succ_le_succ_iff_of_not_is_max Order.succ_le_succ_iff_of_not_isMax
 
 @[simp, mono]
@@ -642,7 +644,7 @@ theorem le_pred_iff_of_not_isMin (ha : ¬IsMin a) : b ≤ pred a ↔ b < a :=
 #align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMin
 
 lemma pred_lt_pred_of_not_isMin (h : a < b) (ha : ¬ IsMin a) : pred a < pred b :=
-(pred_lt_iff_of_not_isMin ha).2 $ le_pred_of_lt h
+  (pred_lt_iff_of_not_isMin ha).2 $ le_pred_of_lt h
 
 @[simp, mono]
 theorem pred_le_pred {a b : α} (h : a ≤ b) : pred a ≤ pred b :=
@@ -1473,7 +1475,7 @@ section bdd_range
 variable [Preorder α] [Nonempty α] [Preorder β] {f : α → β}
 
 lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchimedean β]
-  (hf : StrictMono f) : ¬ BddAbove (Set.range f) := by
+    (hf : StrictMono f) : ¬ BddAbove (Set.range f) := by
   rintro ⟨m, hm⟩
   have hm' : ∀ a, f a ≤ m := λ a ↦ hm $ Set.mem_range_self _
   obtain ⟨a₀⟩ := ‹Nonempty α›
@@ -1482,7 +1484,7 @@ lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchim
     exact ha.not_le (hm' a)
   have h : ∀ a, ∃ a', f a < f a' := λ a ↦ (exists_gt a).imp (λ a' h ↦ hf h)
   apply Succ.rec
-  { exact h a₀ }
+  · exact h a₀
   rintro b _ ⟨a, hba⟩
   exact (h a).imp (λ a' ↦ (succ_le_of_lt hba).trans_lt)
 

Many proofs use the "stream of consciousness" style from Lean 3, rather than have ... := or suffices ... from/by.

This PR updates a fraction of these to the preferred Lean 4 style.

I think a good goal would be to delete the "deferred" versions of have, suffices, and let at the bottom of Mathlib.Tactic.Have

(Anyone who would like to contribute more cleanup is welcome to push directly to this branch.)

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

@@ -1477,9 +1477,9 @@ lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchim
   rintro ⟨m, hm⟩
   have hm' : ∀ a, f a ≤ m := λ a ↦ hm $ Set.mem_range_self _
   obtain ⟨a₀⟩ := ‹Nonempty α›
-  suffices : ∀ b, f a₀ ≤ b → ∃ a, b < f a
-  { obtain ⟨a, ha⟩ : ∃ a, m < f a := this m (hm' a₀)
-    exact ha.not_le (hm' a) }
+  suffices ∀ b, f a₀ ≤ b → ∃ a, b < f a by
+    obtain ⟨a, ha⟩ : ∃ a, m < f a := this m (hm' a₀)
+    exact ha.not_le (hm' a)
   have h : ∀ a, ∃ a', f a < f a' := λ a ↦ (exists_gt a).imp (λ a' h ↦ hf h)
   apply Succ.rec
   { exact h a₀ }

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

@@ -56,7 +56,7 @@ class SuccPredOrder (α : Type*) [Preorder α] extends SuccOrder α, PredOrder 
 
 open Function OrderDual Set
 
-variable {α : Type*}
+variable {α β : Type*}
 
 /-- Order equipped with a sensible successor function. -/
 @[ext]
@@ -255,6 +255,9 @@ theorem succ_le_iff_of_not_isMax (ha : ¬IsMax a) : succ a ≤ b ↔ a < b :=
   ⟨(lt_succ_of_not_isMax ha).trans_le, succ_le_of_lt⟩
 #align order.succ_le_iff_of_not_is_max Order.succ_le_iff_of_not_isMax
 
+lemma succ_lt_succ_of_not_isMax (h : a < b) (hb : ¬ IsMax b) : succ a < succ b :=
+(lt_succ_iff_of_not_isMax hb).2 $ succ_le_of_lt h
+
 theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) : succ a < succ b ↔ a < b :=
   by rw [lt_succ_iff_of_not_isMax hb, succ_le_iff_of_not_isMax ha]
 #align order.succ_lt_succ_iff_of_not_is_max Order.succ_lt_succ_iff_of_not_isMax
@@ -638,6 +641,9 @@ theorem le_pred_iff_of_not_isMin (ha : ¬IsMin a) : b ≤ pred a ↔ b < a :=
   ⟨fun h => h.trans_lt <| pred_lt_of_not_isMin ha, le_pred_of_lt⟩
 #align order.le_pred_iff_of_not_is_min Order.le_pred_iff_of_not_isMin
 
+lemma pred_lt_pred_of_not_isMin (h : a < b) (ha : ¬ IsMin a) : pred a < pred b :=
+(pred_lt_iff_of_not_isMin ha).2 $ le_pred_of_lt h
+
 @[simp, mono]
 theorem pred_le_pred {a b : α} (h : a ≤ b) : pred a ≤ pred b :=
   succ_le_succ h.dual
@@ -1463,6 +1469,34 @@ end PredOrder
 
 end LinearOrder
 
+section bdd_range
+variable [Preorder α] [Nonempty α] [Preorder β] {f : α → β}
+
+lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchimedean β]
+  (hf : StrictMono f) : ¬ BddAbove (Set.range f) := by
+  rintro ⟨m, hm⟩
+  have hm' : ∀ a, f a ≤ m := λ a ↦ hm $ Set.mem_range_self _
+  obtain ⟨a₀⟩ := ‹Nonempty α›
+  suffices : ∀ b, f a₀ ≤ b → ∃ a, b < f a
+  { obtain ⟨a, ha⟩ : ∃ a, m < f a := this m (hm' a₀)
+    exact ha.not_le (hm' a) }
+  have h : ∀ a, ∃ a', f a < f a' := λ a ↦ (exists_gt a).imp (λ a' h ↦ hf h)
+  apply Succ.rec
+  { exact h a₀ }
+  rintro b _ ⟨a, hba⟩
+  exact (h a).imp (λ a' ↦ (succ_le_of_lt hba).trans_lt)
+
+lemma StrictMono.not_bddBelow_range [NoMinOrder α] [PredOrder β] [IsPredArchimedean β]
+  (hf : StrictMono f) : ¬ BddBelow (Set.range f) := hf.dual.not_bddAbove_range
+
+lemma StrictAnti.not_bddAbove_range [NoMinOrder α] [SuccOrder β] [IsSuccArchimedean β]
+  (hf : StrictAnti f) : ¬ BddAbove (Set.range f) := hf.dual_right.not_bddBelow_range
+
+lemma StrictAnti.not_bddBelow_range [NoMaxOrder α] [PredOrder β] [IsPredArchimedean β]
+  (hf : StrictAnti f) : ¬ BddBelow (Set.range f) := hf.dual_right.not_bddAbove_range
+
+end bdd_range
+
 section IsWellOrder
 
 variable [LinearOrder α]

@@ -236,7 +236,7 @@ theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a :=
   ⟨not_isMax_of_lt, fun ha => (le_succ a).lt_of_not_le fun h => ha <| max_of_succ_le h⟩
 #align order.lt_succ_iff_not_is_max Order.lt_succ_iff_not_isMax
 
-alias lt_succ_iff_not_isMax ↔ _ lt_succ_of_not_isMax
+alias ⟨_, lt_succ_of_not_isMax⟩ := lt_succ_iff_not_isMax
 #align order.lt_succ_of_not_is_max Order.lt_succ_of_not_isMax
 
 theorem wcovby_succ (a : α) : a ⩿ succ a :=
@@ -345,10 +345,10 @@ theorem succ_le_succ_iff : succ a ≤ succ b ↔ a ≤ b := by simp
 theorem succ_lt_succ_iff : succ a < succ b ↔ a < b := by simp
 #align order.succ_lt_succ_iff Order.succ_lt_succ_iff
 
-alias succ_le_succ_iff ↔ le_of_succ_le_succ _
+alias ⟨le_of_succ_le_succ, _⟩ := succ_le_succ_iff
 #align order.le_of_succ_le_succ Order.le_of_succ_le_succ
 
-alias succ_lt_succ_iff ↔ lt_of_succ_lt_succ succ_lt_succ
+alias ⟨lt_of_succ_lt_succ, succ_lt_succ⟩ := succ_lt_succ_iff
 #align order.lt_of_succ_lt_succ Order.lt_of_succ_lt_succ
 #align order.succ_lt_succ Order.succ_lt_succ
 
@@ -402,7 +402,7 @@ theorem succ_eq_iff_isMax : succ a = a ↔ IsMax a :=
   ⟨fun h => max_of_succ_le h.le, fun h => h.eq_of_ge <| le_succ _⟩
 #align order.succ_eq_iff_is_max Order.succ_eq_iff_isMax
 
-alias succ_eq_iff_isMax ↔ _ _root_.IsMax.succ_eq
+alias ⟨_, _root_.IsMax.succ_eq⟩ := succ_eq_iff_isMax
 #align is_max.succ_eq IsMax.succ_eq
 
 theorem succ_eq_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
@@ -484,7 +484,7 @@ theorem succ_ne_succ_iff : succ a ≠ succ b ↔ a ≠ b :=
   succ_injective.ne_iff
 #align order.succ_ne_succ_iff Order.succ_ne_succ_iff
 
-alias succ_ne_succ_iff ↔ _ succ_ne_succ
+alias ⟨_, succ_ne_succ⟩ := succ_ne_succ_iff
 #align order.succ_ne_succ Order.succ_ne_succ
 
 theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b :=
@@ -619,7 +619,7 @@ theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a :=
   ⟨not_isMin_of_lt, fun ha => (pred_le a).lt_of_not_le fun h => ha <| min_of_le_pred h⟩
 #align order.pred_lt_iff_not_is_min Order.pred_lt_iff_not_isMin
 
-alias pred_lt_iff_not_isMin ↔ _ pred_lt_of_not_isMin
+alias ⟨_, pred_lt_of_not_isMin⟩ := pred_lt_iff_not_isMin
 #align order.pred_lt_of_not_is_min Order.pred_lt_of_not_isMin
 
 theorem pred_wcovby (a : α) : pred a ⩿ a :=
@@ -709,10 +709,10 @@ theorem pred_le_pred_iff : pred a ≤ pred b ↔ a ≤ b := by simp
 theorem pred_lt_pred_iff : pred a < pred b ↔ a < b := by simp
 #align order.pred_lt_pred_iff Order.pred_lt_pred_iff
 
-alias pred_le_pred_iff ↔ le_of_pred_le_pred _
+alias ⟨le_of_pred_le_pred, _⟩ := pred_le_pred_iff
 #align order.le_of_pred_le_pred Order.le_of_pred_le_pred
 
-alias pred_lt_pred_iff ↔ lt_of_pred_lt_pred pred_lt_pred
+alias ⟨lt_of_pred_lt_pred, pred_lt_pred⟩ := pred_lt_pred_iff
 #align order.lt_of_pred_lt_pred Order.lt_of_pred_lt_pred
 #align order.pred_lt_pred Order.pred_lt_pred
 
@@ -766,7 +766,7 @@ theorem pred_eq_iff_isMin : pred a = a ↔ IsMin a :=
   ⟨fun h => min_of_le_pred h.ge, fun h => h.eq_of_le <| pred_le _⟩
 #align order.pred_eq_iff_is_min Order.pred_eq_iff_isMin
 
-alias pred_eq_iff_isMin ↔ _ _root_.IsMin.pred_eq
+alias ⟨_, _root_.IsMin.pred_eq⟩ := pred_eq_iff_isMin
 #align is_min.pred_eq IsMin.pred_eq
 
 theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a := by
@@ -831,7 +831,7 @@ theorem pred_ne_pred_iff : pred a ≠ pred b ↔ a ≠ b :=
   pred_injective.ne_iff
 #align order.pred_ne_pred_iff Order.pred_ne_pred_iff
 
-alias pred_ne_pred_iff ↔ _ pred_ne_pred
+alias ⟨_, pred_ne_pred⟩ := pred_ne_pred_iff
 #align order.pred_ne_pred Order.pred_ne_pred
 
 theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b :=

We remove all possible occurences of Type _ and Sort _ in favor of Type* and Sort*.

This has nice performance benefits.

@@ -30,7 +30,7 @@ order...
 
 Maximal elements don't have a sensible successor. Thus the naïve typeclass
 ```lean
-class NaiveSuccOrder (α : Type _) [Preorder α] :=
+class NaiveSuccOrder (α : Type*) [Preorder α] :=
   (succ : α → α)
   (succ_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b)
   (lt_succ_iff : ∀ {a b}, a < succ b ↔ a ≤ b)
@@ -47,7 +47,7 @@ combination of `SuccOrder α` and `NoMaxOrder α`.
 
 Is `GaloisConnection pred succ` always true? If not, we should introduce
 ```lean
-class SuccPredOrder (α : Type _) [Preorder α] extends SuccOrder α, PredOrder α :=
+class SuccPredOrder (α : Type*) [Preorder α] extends SuccOrder α, PredOrder α :=
   (pred_succ_gc : GaloisConnection (pred : α → α) succ)
 ```
 `Covby` should help here.
@@ -56,11 +56,11 @@ class SuccPredOrder (α : Type _) [Preorder α] extends SuccOrder α, PredOrder
 
 open Function OrderDual Set
 
-variable {α : Type _}
+variable {α : Type*}
 
 /-- Order equipped with a sensible successor function. -/
 @[ext]
-class SuccOrder (α : Type _) [Preorder α] where
+class SuccOrder (α : Type*) [Preorder α] where
   /--Successor function-/
   succ : α → α
   /--Proof of basic ordering with respect to `succ`-/
@@ -77,7 +77,7 @@ class SuccOrder (α : Type _) [Preorder α] where
 
 /-- Order equipped with a sensible predecessor function. -/
 @[ext]
-class PredOrder (α : Type _) [Preorder α] where
+class PredOrder (α : Type*) [Preorder α] where
   /--Predecessor function-/
   pred : α → α
   /--Proof of basic ordering with respect to `pred`-/
@@ -1342,14 +1342,14 @@ end WithBot
 
 /-- A `SuccOrder` is succ-archimedean if one can go from any two comparable elements by iterating
 `succ` -/
-class IsSuccArchimedean (α : Type _) [Preorder α] [SuccOrder α] : Prop where
+class IsSuccArchimedean (α : Type*) [Preorder α] [SuccOrder α] : Prop where
   /-- If `a ≤ b` then one can get to `a` from `b` by iterating `succ` -/
   exists_succ_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, succ^[n] a = b
 #align is_succ_archimedean IsSuccArchimedean
 
 /-- A `PredOrder` is pred-archimedean if one can go from any two comparable elements by iterating
 `pred` -/
-class IsPredArchimedean (α : Type _) [Preorder α] [PredOrder α] : Prop where
+class IsPredArchimedean (α : Type*) [Preorder α] [PredOrder α] : Prop where
   /-- If `a ≤ b` then one can get to `b` from `a` by iterating `pred` -/
   exists_pred_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, pred^[n] b = a
 #align is_pred_archimedean IsPredArchimedean

@@ -1511,3 +1511,14 @@ theorem Pred.rec_top (p : α → Prop) (htop : p ⊤) (hpred : ∀ a, p a → p
 #align pred.rec_top Pred.rec_top
 
 end OrderTop
+
+lemma SuccOrder.forall_ne_bot_iff
+    [Nontrivial α] [PartialOrder α] [OrderBot α] [SuccOrder α] [IsSuccArchimedean α]
+    (P : α → Prop) :
+    (∀ i, i ≠ ⊥ → P i) ↔ (∀ i, P (SuccOrder.succ i)) := by
+  refine' ⟨fun h i ↦ h _ (Order.succ_ne_bot i), fun h i hi ↦ _⟩
+  obtain ⟨j, rfl⟩ := exists_succ_iterate_of_le (bot_le : ⊥ ≤ i)
+  have hj : 0 < j := by apply Nat.pos_of_ne_zero; contrapose! hi; simp [hi]
+  rw [← Nat.succ_pred_eq_of_pos hj]
+  simp only [Function.iterate_succ', Function.comp_apply]
+  apply h