order.succ_pred.limit ⟷ Mathlib.Order.SuccPred.Limit

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

@@ -118,7 +118,7 @@ theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a
   by
   rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩
   · exact le_rfl
-  · rw [iterate_succ_apply'] at h 
+  · rw [iterate_succ_apply'] at h
     exact (not_is_succ_limit_succ _ h).elim
 #align order.is_succ_limit.is_min_of_no_max Order.IsSuccLimit.isMin_of_noMax
 -/

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

@@ -212,7 +212,8 @@ noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a
 
 #print Order.isSuccLimitRecOn_limit /-
 theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
-    (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb := by classical
+    (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb := by
+  classical exact dif_pos hb
 #align order.is_succ_limit_rec_on_limit Order.isSuccLimitRecOn_limit
 -/
 

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

@@ -212,8 +212,7 @@ noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a
 
 #print Order.isSuccLimitRecOn_limit /-
 theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
-    (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb := by
-  classical exact dif_pos hb
+    (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb := by classical
 #align order.is_succ_limit_rec_on_limit Order.isSuccLimitRecOn_limit
 -/
 

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

@@ -47,15 +47,15 @@ def IsSuccLimit (a : α) : Prop :=
 #align order.is_succ_limit Order.IsSuccLimit
 -/
 
-#print Order.not_isSuccLimit_iff_exists_covby /-
-theorem not_isSuccLimit_iff_exists_covby (a : α) : ¬IsSuccLimit a ↔ ∃ b, b ⋖ a := by
+#print Order.not_isSuccLimit_iff_exists_covBy /-
+theorem not_isSuccLimit_iff_exists_covBy (a : α) : ¬IsSuccLimit a ↔ ∃ b, b ⋖ a := by
   simp [is_succ_limit]
-#align order.not_is_succ_limit_iff_exists_covby Order.not_isSuccLimit_iff_exists_covby
+#align order.not_is_succ_limit_iff_exists_covby Order.not_isSuccLimit_iff_exists_covBy
 -/
 
 #print Order.isSuccLimit_of_dense /-
 @[simp]
-theorem isSuccLimit_of_dense [DenselyOrdered α] (a : α) : IsSuccLimit a := fun b => not_covby
+theorem isSuccLimit_of_dense [DenselyOrdered α] (a : α) : IsSuccLimit a := fun b => not_covBy
 #align order.is_succ_limit_of_dense Order.isSuccLimit_of_dense
 -/
 
@@ -305,14 +305,14 @@ def IsPredLimit (a : α) : Prop :=
 #align order.is_pred_limit Order.IsPredLimit
 -/
 
-#print Order.not_isPredLimit_iff_exists_covby /-
-theorem not_isPredLimit_iff_exists_covby (a : α) : ¬IsPredLimit a ↔ ∃ b, a ⋖ b := by
+#print Order.not_isPredLimit_iff_exists_covBy /-
+theorem not_isPredLimit_iff_exists_covBy (a : α) : ¬IsPredLimit a ↔ ∃ b, a ⋖ b := by
   simp [is_pred_limit]
-#align order.not_is_pred_limit_iff_exists_covby Order.not_isPredLimit_iff_exists_covby
+#align order.not_is_pred_limit_iff_exists_covby Order.not_isPredLimit_iff_exists_covBy
 -/
 
 #print Order.isPredLimit_of_dense /-
-theorem isPredLimit_of_dense [DenselyOrdered α] (a : α) : IsPredLimit a := fun b => not_covby
+theorem isPredLimit_of_dense [DenselyOrdered α] (a : α) : IsPredLimit a := fun b => not_covBy
 #align order.is_pred_limit_of_dense Order.isPredLimit_of_dense
 -/
 

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

@@ -251,7 +251,7 @@ theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a :=
 
 #print Order.not_isSuccLimit_iff' /-
 theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) := by
-  simp_rw [is_succ_limit_iff_succ_ne, not_forall, not_ne_iff]; rfl
+  simp_rw [is_succ_limit_iff_succ_ne, Classical.not_forall, not_ne_iff]; rfl
 #align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'
 -/
 

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

@@ -3,7 +3,7 @@ Copyright (c) 2022 Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
 -/
-import Mathbin.Order.SuccPred.Basic
+import Order.SuccPred.Basic
 
 #align_import order.succ_pred.limit from "leanprover-community/mathlib"@"baba818b9acea366489e8ba32d2cc0fcaf50a1f7"
 

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

@@ -330,10 +330,10 @@ theorem isPredLimit_toDual_iff : IsPredLimit (toDual a) ↔ IsSuccLimit a := by
 #align order.is_pred_limit_to_dual_iff Order.isPredLimit_toDual_iff
 -/
 
-alias is_succ_limit_to_dual_iff ↔ _ is_pred_limit.dual
+alias ⟨_, is_pred_limit.dual⟩ := is_succ_limit_to_dual_iff
 #align order.is_pred_limit.dual Order.isPredLimit.dual
 
-alias is_pred_limit_to_dual_iff ↔ _ is_succ_limit.dual
+alias ⟨_, is_succ_limit.dual⟩ := is_pred_limit_to_dual_iff
 #align order.is_succ_limit.dual Order.isSuccLimit.dual
 
 end LT

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

@@ -2,14 +2,11 @@
 Copyright (c) 2022 Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
-
-! This file was ported from Lean 3 source module order.succ_pred.limit
-! leanprover-community/mathlib commit baba818b9acea366489e8ba32d2cc0fcaf50a1f7
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Order.SuccPred.Basic
 
+#align_import order.succ_pred.limit from "leanprover-community/mathlib"@"baba818b9acea366489e8ba32d2cc0fcaf50a1f7"
+
 /-!
 # Successor and predecessor limits
 

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

@@ -74,9 +74,11 @@ protected theorem IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h b hab =
 #align is_min.is_succ_limit IsMin.isSuccLimit
 -/
 
+#print Order.isSuccLimit_bot /-
 theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) :=
   isMin_bot.IsSuccLimit
 #align order.is_succ_limit_bot Order.isSuccLimit_bot
+-/
 
 variable [SuccOrder α]
 
@@ -211,11 +213,14 @@ noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a
 #align order.is_succ_limit_rec_on Order.isSuccLimitRecOn
 -/
 
+#print Order.isSuccLimitRecOn_limit /-
 theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
     (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb := by
   classical exact dif_pos hb
 #align order.is_succ_limit_rec_on_limit Order.isSuccLimitRecOn_limit
+-/
 
+#print Order.isSuccLimitRecOn_succ' /-
 theorem isSuccLimitRecOn_succ' (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
     {b : α} (hb : ¬IsMax b) : @isSuccLimitRecOn α _ _ C (succ b) hs hl = hs b hb :=
   by
@@ -227,16 +232,19 @@ theorem isSuccLimitRecOn_succ' (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀
   · exact (succ_eq_succ_iff_of_not_is_max H.1 hb).1 H.2
   · apply proof_irrel_heq
 #align order.is_succ_limit_rec_on_succ' Order.isSuccLimitRecOn_succ'
+-/
 
 section NoMaxOrder
 
 variable [NoMaxOrder α]
 
+#print Order.isSuccLimitRecOn_succ /-
 @[simp]
 theorem isSuccLimitRecOn_succ (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
     (b : α) : @isSuccLimitRecOn α _ _ C (succ b) hs hl = hs b (not_isMax b) :=
   isSuccLimitRecOn_succ' _ _ _
 #align order.is_succ_limit_rec_on_succ Order.isSuccLimitRecOn_succ
+-/
 
 #print Order.isSuccLimit_iff_succ_ne /-
 theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a :=
@@ -343,9 +351,11 @@ protected theorem IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h b hab =
 #align is_max.is_pred_limit IsMax.isPredLimit
 -/
 
+#print Order.isPredLimit_top /-
 theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) :=
   isMax_top.IsPredLimit
 #align order.is_pred_limit_top Order.isPredLimit_top
+-/
 
 variable [PredOrder α]
 
@@ -461,25 +471,31 @@ noncomputable def isPredLimitRecOn (b : α) (hs : ∀ a, ¬IsMin a → C (pred a
 #align order.is_pred_limit_rec_on Order.isPredLimitRecOn
 -/
 
+#print Order.isPredLimitRecOn_limit /-
 theorem isPredLimitRecOn_limit (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
     (hb : IsPredLimit b) : @isPredLimitRecOn α _ _ C b hs hl = hl b hb :=
   isSuccLimitRecOn_limit _ _ hb.dual
 #align order.is_pred_limit_rec_on_limit Order.isPredLimitRecOn_limit
+-/
 
+#print Order.isPredLimitRecOn_pred' /-
 theorem isPredLimitRecOn_pred' (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
     {b : α} (hb : ¬IsMin b) : @isPredLimitRecOn α _ _ C (pred b) hs hl = hs b hb :=
   isSuccLimitRecOn_succ' _ _ _
 #align order.is_pred_limit_rec_on_pred' Order.isPredLimitRecOn_pred'
+-/
 
 section NoMinOrder
 
 variable [NoMinOrder α]
 
+#print Order.isPredLimitRecOn_pred /-
 @[simp]
 theorem isPredLimitRecOn_pred (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
     (b : α) : @isPredLimitRecOn α _ _ C (pred b) hs hl = hs b (not_isMin b) :=
   isSuccLimitRecOn_succ _ _ _
 #align order.is_pred_limit_rec_on_pred Order.isPredLimitRecOn_pred
+-/
 
 end NoMinOrder
 

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

@@ -119,7 +119,7 @@ theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a
   by
   rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩
   · exact le_rfl
-  · rw [iterate_succ_apply'] at h
+  · rw [iterate_succ_apply'] at h 
     exact (not_is_succ_limit_succ _ h).elim
 #align order.is_succ_limit.is_min_of_no_max Order.IsSuccLimit.isMin_of_noMax
 -/
@@ -262,7 +262,7 @@ protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   revert h
   refine' Succ.rec (fun _ => le_rfl) (fun c hbc H hc => _) hb
   have := hc.is_max.succ_eq
-  rw [this] at hc⊢
+  rw [this] at hc ⊢
   exact H hc
 #align order.is_succ_limit.is_min Order.IsSuccLimit.isMin
 -/

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

@@ -68,9 +68,11 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
+#print IsMin.isSuccLimit /-
 protected theorem IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h b hab =>
   not_isMin_of_lt hab.lt h
 #align is_min.is_succ_limit IsMin.isSuccLimit
+-/
 
 theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) :=
   isMin_bot.IsSuccLimit
@@ -78,25 +80,33 @@ theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) :=
 
 variable [SuccOrder α]
 
+#print Order.IsSuccLimit.isMax /-
 protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a := by by_contra H;
   exact h a (covby_succ_of_not_is_max H)
 #align order.is_succ_limit.is_max Order.IsSuccLimit.isMax
+-/
 
+#print Order.not_isSuccLimit_succ_of_not_isMax /-
 theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) := by
   contrapose! ha; exact ha.is_max
 #align order.not_is_succ_limit_succ_of_not_is_max Order.not_isSuccLimit_succ_of_not_isMax
+-/
 
 section NoMaxOrder
 
 variable [NoMaxOrder α]
 
+#print Order.IsSuccLimit.succ_ne /-
 theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a := by rintro rfl;
   exact not_isMax _ h.is_max
 #align order.is_succ_limit.succ_ne Order.IsSuccLimit.succ_ne
+-/
 
+#print Order.not_isSuccLimit_succ /-
 @[simp]
 theorem not_isSuccLimit_succ (a : α) : ¬IsSuccLimit (succ a) := fun h => h.succ_ne _ rfl
 #align order.not_is_succ_limit_succ Order.not_isSuccLimit_succ
+-/
 
 end NoMaxOrder
 
@@ -104,6 +114,7 @@ section IsSuccArchimedean
 
 variable [IsSuccArchimedean α]
 
+#print Order.IsSuccLimit.isMin_of_noMax /-
 theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a := fun b hb =>
   by
   rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩
@@ -111,14 +122,19 @@ theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a
   · rw [iterate_succ_apply'] at h
     exact (not_is_succ_limit_succ _ h).elim
 #align order.is_succ_limit.is_min_of_no_max Order.IsSuccLimit.isMin_of_noMax
+-/
 
+#print Order.isSuccLimit_iff_of_noMax /-
 @[simp]
 theorem isSuccLimit_iff_of_noMax [NoMaxOrder α] : IsSuccLimit a ↔ IsMin a :=
   ⟨IsSuccLimit.isMin_of_noMax, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff_of_no_max Order.isSuccLimit_iff_of_noMax
+-/
 
+#print Order.not_isSuccLimit_of_noMax /-
 theorem not_isSuccLimit_of_noMax [NoMinOrder α] [NoMaxOrder α] : ¬IsSuccLimit a := by simp
 #align order.not_is_succ_limit_of_no_max Order.not_isSuccLimit_of_noMax
+-/
 
 end IsSuccArchimedean
 
@@ -128,9 +144,12 @@ section PartialOrder
 
 variable [PartialOrder α] [SuccOrder α] {a b : α} {C : α → Sort _}
 
+#print Order.isSuccLimit_of_succ_ne /-
 theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a := fun b hba => h b hba.succ_eq
 #align order.is_succ_limit_of_succ_ne Order.isSuccLimit_of_succ_ne
+-/
 
+#print Order.not_isSuccLimit_iff /-
 theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a :=
   by
   rw [not_is_succ_limit_iff_exists_covby]
@@ -138,17 +157,23 @@ theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b =
   rintro ⟨h, rfl⟩
   exact covby_succ_of_not_is_max h
 #align order.not_is_succ_limit_iff Order.not_isSuccLimit_iff
+-/
 
+#print Order.mem_range_succ_of_not_isSuccLimit /-
 /-- See `not_is_succ_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
 theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@succ α _ _) := by
   cases' not_is_succ_limit_iff.1 h with b hb; exact ⟨b, hb.2⟩
 #align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimit
+-/
 
+#print Order.isSuccLimit_of_succ_lt /-
 theorem isSuccLimit_of_succ_lt (H : ∀ a < b, succ a < b) : IsSuccLimit b := fun a hab =>
   (H a hab.lt).Ne hab.succ_eq
 #align order.is_succ_limit_of_succ_lt Order.isSuccLimit_of_succ_lt
+-/
 
+#print Order.IsSuccLimit.succ_lt /-
 theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b :=
   by
   by_cases h : IsMax a
@@ -158,15 +183,21 @@ theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b :=
     subst hab
     exact (h hb.is_max).elim
 #align order.is_succ_limit.succ_lt Order.IsSuccLimit.succ_lt
+-/
 
+#print Order.IsSuccLimit.succ_lt_iff /-
 theorem IsSuccLimit.succ_lt_iff (hb : IsSuccLimit b) : succ a < b ↔ a < b :=
   ⟨fun h => (le_succ a).trans_lt h, hb.succ_lt⟩
 #align order.is_succ_limit.succ_lt_iff Order.IsSuccLimit.succ_lt_iff
+-/
 
+#print Order.isSuccLimit_iff_succ_lt /-
 theorem isSuccLimit_iff_succ_lt : IsSuccLimit b ↔ ∀ a < b, succ a < b :=
   ⟨fun hb a => hb.succ_lt, isSuccLimit_of_succ_lt⟩
 #align order.is_succ_limit_iff_succ_lt Order.isSuccLimit_iff_succ_lt
+-/
 
+#print Order.isSuccLimitRecOn /-
 /-- A value can be built by building it on successors and successor limits. -/
 @[elab_as_elim]
 noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a))
@@ -178,6 +209,7 @@ noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a
     rw [← H.2]
     exact hs _ H.1
 #align order.is_succ_limit_rec_on Order.isSuccLimitRecOn
+-/
 
 theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
     (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb := by
@@ -206,13 +238,17 @@ theorem isSuccLimitRecOn_succ (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a
   isSuccLimitRecOn_succ' _ _ _
 #align order.is_succ_limit_rec_on_succ Order.isSuccLimitRecOn_succ
 
+#print Order.isSuccLimit_iff_succ_ne /-
 theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a :=
   ⟨IsSuccLimit.succ_ne, isSuccLimit_of_succ_ne⟩
 #align order.is_succ_limit_iff_succ_ne Order.isSuccLimit_iff_succ_ne
+-/
 
+#print Order.not_isSuccLimit_iff' /-
 theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) := by
   simp_rw [is_succ_limit_iff_succ_ne, not_forall, not_ne_iff]; rfl
 #align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'
+-/
 
 end NoMaxOrder
 
@@ -220,6 +256,7 @@ section IsSuccArchimedean
 
 variable [IsSuccArchimedean α]
 
+#print Order.IsSuccLimit.isMin /-
 protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   by
   revert h
@@ -228,14 +265,19 @@ protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   rw [this] at hc⊢
   exact H hc
 #align order.is_succ_limit.is_min Order.IsSuccLimit.isMin
+-/
 
+#print Order.isSuccLimit_iff /-
 @[simp]
 theorem isSuccLimit_iff : IsSuccLimit a ↔ IsMin a :=
   ⟨IsSuccLimit.isMin, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff Order.isSuccLimit_iff
+-/
 
+#print Order.not_isSuccLimit /-
 theorem not_isSuccLimit [NoMinOrder α] : ¬IsSuccLimit a := by simp
 #align order.not_is_succ_limit Order.not_isSuccLimit
+-/
 
 end IsSuccArchimedean
 
@@ -295,9 +337,11 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
+#print IsMax.isPredLimit /-
 protected theorem IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h b hab =>
   not_isMax_of_lt hab.lt h
 #align is_max.is_pred_limit IsMax.isPredLimit
+-/
 
 theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) :=
   isMax_top.IsPredLimit
@@ -305,25 +349,33 @@ theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) :=
 
 variable [PredOrder α]
 
+#print Order.IsPredLimit.isMin /-
 protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a := by by_contra H;
   exact h a (pred_covby_of_not_is_min H)
 #align order.is_pred_limit.is_min Order.IsPredLimit.isMin
+-/
 
+#print Order.not_isPredLimit_pred_of_not_isMin /-
 theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) := by
   contrapose! ha; exact ha.is_min
 #align order.not_is_pred_limit_pred_of_not_is_min Order.not_isPredLimit_pred_of_not_isMin
+-/
 
 section NoMinOrder
 
 variable [NoMinOrder α]
 
+#print Order.IsPredLimit.pred_ne /-
 theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a := by rintro rfl;
   exact not_isMin _ h.is_min
 #align order.is_pred_limit.pred_ne Order.IsPredLimit.pred_ne
+-/
 
+#print Order.not_isPredLimit_pred /-
 @[simp]
 theorem not_isPredLimit_pred (a : α) : ¬IsPredLimit (pred a) := fun h => h.pred_ne _ rfl
 #align order.not_is_pred_limit_pred Order.not_isPredLimit_pred
+-/
 
 end NoMinOrder
 
@@ -331,17 +383,23 @@ section IsPredArchimedean
 
 variable [IsPredArchimedean α]
 
+#print Order.IsPredLimit.isMax_of_noMin /-
 protected theorem IsPredLimit.isMax_of_noMin [NoMinOrder α] (h : IsPredLimit a) : IsMax a :=
   h.dual.isMin_of_noMax
 #align order.is_pred_limit.is_max_of_no_min Order.IsPredLimit.isMax_of_noMin
+-/
 
+#print Order.isPredLimit_iff_of_noMin /-
 @[simp]
 theorem isPredLimit_iff_of_noMin [NoMinOrder α] : IsPredLimit a ↔ IsMax a :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff_of_noMax
 #align order.is_pred_limit_iff_of_no_min Order.isPredLimit_iff_of_noMin
+-/
 
+#print Order.not_isPredLimit_of_noMin /-
 theorem not_isPredLimit_of_noMin [NoMinOrder α] [NoMaxOrder α] : ¬IsPredLimit a := by simp
 #align order.not_is_pred_limit_of_no_min Order.not_isPredLimit_of_noMin
+-/
 
 end IsPredArchimedean
 
@@ -351,41 +409,57 @@ section PartialOrder
 
 variable [PartialOrder α] [PredOrder α] {a b : α} {C : α → Sort _}
 
+#print Order.isPredLimit_of_pred_ne /-
 theorem isPredLimit_of_pred_ne (h : ∀ b, pred b ≠ a) : IsPredLimit a := fun b hba => h b hba.pred_eq
 #align order.is_pred_limit_of_pred_ne Order.isPredLimit_of_pred_ne
+-/
 
+#print Order.not_isPredLimit_iff /-
 theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a := by
   rw [← is_succ_limit_to_dual_iff]; exact not_is_succ_limit_iff
 #align order.not_is_pred_limit_iff Order.not_isPredLimit_iff
+-/
 
+#print Order.mem_range_pred_of_not_isPredLimit /-
 /-- See `not_is_pred_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
 theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@pred α _ _) := by
   cases' not_is_pred_limit_iff.1 h with b hb; exact ⟨b, hb.2⟩
 #align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimit
+-/
 
+#print Order.isPredLimit_of_pred_lt /-
 theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b := fun a hab =>
   (H a hab.lt).Ne hab.pred_eq
 #align order.is_pred_limit_of_pred_lt Order.isPredLimit_of_pred_lt
+-/
 
+#print Order.IsPredLimit.lt_pred /-
 theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b :=
   h.dual.succ_lt
 #align order.is_pred_limit.lt_pred Order.IsPredLimit.lt_pred
+-/
 
+#print Order.IsPredLimit.lt_pred_iff /-
 theorem IsPredLimit.lt_pred_iff (h : IsPredLimit a) : a < pred b ↔ a < b :=
   h.dual.succ_lt_iff
 #align order.is_pred_limit.lt_pred_iff Order.IsPredLimit.lt_pred_iff
+-/
 
+#print Order.isPredLimit_iff_lt_pred /-
 theorem isPredLimit_iff_lt_pred : IsPredLimit a ↔ ∀ ⦃b⦄, a < b → a < pred b :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff_succ_lt
 #align order.is_pred_limit_iff_lt_pred Order.isPredLimit_iff_lt_pred
+-/
 
+#print Order.isPredLimitRecOn /-
 /-- A value can be built by building it on predecessors and predecessor limits. -/
 @[elab_as_elim]
 noncomputable def isPredLimitRecOn (b : α) (hs : ∀ a, ¬IsMin a → C (pred a))
     (hl : ∀ a, IsPredLimit a → C a) : C b :=
   @isSuccLimitRecOn αᵒᵈ _ _ _ _ hs fun a ha => hl _ ha.dual
 #align order.is_pred_limit_rec_on Order.isPredLimitRecOn
+-/
 
 theorem isPredLimitRecOn_limit (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
     (hb : IsPredLimit b) : @isPredLimitRecOn α _ _ C b hs hl = hl b hb :=
@@ -413,17 +487,23 @@ section IsPredArchimedean
 
 variable [IsPredArchimedean α]
 
+#print Order.IsPredLimit.isMax /-
 protected theorem IsPredLimit.isMax (h : IsPredLimit a) : IsMax a :=
   h.dual.IsMin
 #align order.is_pred_limit.is_max Order.IsPredLimit.isMax
+-/
 
+#print Order.isPredLimit_iff /-
 @[simp]
 theorem isPredLimit_iff : IsPredLimit a ↔ IsMax a :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff
 #align order.is_pred_limit_iff Order.isPredLimit_iff
+-/
 
+#print Order.not_isPredLimit /-
 theorem not_isPredLimit [NoMaxOrder α] : ¬IsPredLimit a := by simp
 #align order.not_is_pred_limit Order.not_isPredLimit
+-/
 
 end IsPredArchimedean
 

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

@@ -68,44 +68,20 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-/- warning: is_min.is_succ_limit -> IsMin.isSuccLimit is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align is_min.is_succ_limit IsMin.isSuccLimitₓ'. -/
 protected theorem IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h b hab =>
   not_isMin_of_lt hab.lt h
 #align is_min.is_succ_limit IsMin.isSuccLimit
 
-/- warning: order.is_succ_limit_bot -> Order.isSuccLimit_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)], Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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)], Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_bot Order.isSuccLimit_botₓ'. -/
 theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) :=
   isMin_bot.IsSuccLimit
 #align order.is_succ_limit_bot Order.isSuccLimit_bot
 
 variable [SuccOrder α]
 
-/- warning: order.is_succ_limit.is_max -> Order.IsSuccLimit.isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.is_max Order.IsSuccLimit.isMaxₓ'. -/
 protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a := by by_contra H;
   exact h a (covby_succ_of_not_is_max H)
 #align order.is_succ_limit.is_max Order.IsSuccLimit.isMax
 
-/- warning: order.not_is_succ_limit_succ_of_not_is_max -> Order.not_isSuccLimit_succ_of_not_isMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)))
-Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_succ_of_not_is_max Order.not_isSuccLimit_succ_of_not_isMaxₓ'. -/
 theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) := by
   contrapose! ha; exact ha.is_max
 #align order.not_is_succ_limit_succ_of_not_is_max Order.not_isSuccLimit_succ_of_not_isMax
@@ -114,22 +90,10 @@ section NoMaxOrder
 
 variable [NoMaxOrder α]
 
-/- warning: order.is_succ_limit.succ_ne -> Order.IsSuccLimit.succ_ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2 b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2 b) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.succ_ne Order.IsSuccLimit.succ_neₓ'. -/
 theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a := by rintro rfl;
   exact not_isMax _ h.is_max
 #align order.is_succ_limit.succ_ne Order.IsSuccLimit.succ_ne
 
-/- warning: order.not_is_succ_limit_succ -> Order.not_isSuccLimit_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 : α), Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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 : α), Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_succ Order.not_isSuccLimit_succₓ'. -/
 @[simp]
 theorem not_isSuccLimit_succ (a : α) : ¬IsSuccLimit (succ a) := fun h => h.succ_ne _ rfl
 #align order.not_is_succ_limit_succ Order.not_isSuccLimit_succ
@@ -140,12 +104,6 @@ section IsSuccArchimedean
 
 variable [IsSuccArchimedean α]
 
-/- warning: order.is_succ_limit.is_min_of_no_max -> Order.IsSuccLimit.isMin_of_noMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.is_min_of_no_max Order.IsSuccLimit.isMin_of_noMaxₓ'. -/
 theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a := fun b hb =>
   by
   rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩
@@ -154,23 +112,11 @@ theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a
     exact (not_is_succ_limit_succ _ h).elim
 #align order.is_succ_limit.is_min_of_no_max Order.IsSuccLimit.isMin_of_noMax
 
-/- warning: order.is_succ_limit_iff_of_no_max -> Order.isSuccLimit_iff_of_noMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff_of_no_max Order.isSuccLimit_iff_of_noMaxₓ'. -/
 @[simp]
 theorem isSuccLimit_iff_of_noMax [NoMaxOrder α] : IsSuccLimit a ↔ IsMin a :=
   ⟨IsSuccLimit.isMin_of_noMax, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff_of_no_max Order.isSuccLimit_iff_of_noMax
 
-/- warning: order.not_is_succ_limit_of_no_max -> Order.not_isSuccLimit_of_noMax is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_of_no_max Order.not_isSuccLimit_of_noMaxₓ'. -/
 theorem not_isSuccLimit_of_noMax [NoMinOrder α] [NoMaxOrder α] : ¬IsSuccLimit a := by simp
 #align order.not_is_succ_limit_of_no_max Order.not_isSuccLimit_of_noMax
 
@@ -182,21 +128,9 @@ section PartialOrder
 
 variable [PartialOrder α] [SuccOrder α] {a b : α} {C : α → Sort _}
 
-/- warning: order.is_succ_limit_of_succ_ne -> Order.isSuccLimit_of_succ_ne 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 : α}, (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{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 : α}, (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_of_succ_ne Order.isSuccLimit_of_succ_neₓ'. -/
 theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a := fun b hba => h b hba.succ_eq
 #align order.is_succ_limit_of_succ_ne Order.isSuccLimit_of_succ_ne
 
-/- warning: order.not_is_succ_limit_iff -> Order.not_isSuccLimit_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 : α}, Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) (Eq.{succ u1} α (Order.succ.{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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)))
-Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_iff Order.not_isSuccLimit_iffₓ'. -/
 theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a :=
   by
   rw [not_is_succ_limit_iff_exists_covby]
@@ -205,34 +139,16 @@ theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b =
   exact covby_succ_of_not_is_max h
 #align order.not_is_succ_limit_iff Order.not_isSuccLimit_iff
 
-/- warning: order.mem_range_succ_of_not_is_succ_limit -> Order.mem_range_succ_of_not_isSuccLimit 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 (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.range.{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)] {a : α}, (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.range.{u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimitₓ'. -/
 /-- See `not_is_succ_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
 theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@succ α _ _) := by
   cases' not_is_succ_limit_iff.1 h with b hb; exact ⟨b, hb.2⟩
 #align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimit
 
-/- warning: order.is_succ_limit_of_succ_lt -> Order.isSuccLimit_of_succ_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)] {b : α}, (forall (a : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)) -> (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α}, (forall (a : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)) -> (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_of_succ_lt Order.isSuccLimit_of_succ_ltₓ'. -/
 theorem isSuccLimit_of_succ_lt (H : ∀ a < b, succ a < b) : IsSuccLimit b := fun a hab =>
   (H a hab.lt).Ne hab.succ_eq
 #align order.is_succ_limit_of_succ_lt Order.isSuccLimit_of_succ_lt
 
-/- warning: order.is_succ_limit.succ_lt -> Order.IsSuccLimit.succ_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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.succ_lt Order.IsSuccLimit.succ_ltₓ'. -/
 theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b :=
   by
   by_cases h : IsMax a
@@ -243,32 +159,14 @@ theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b :=
     exact (h hb.is_max).elim
 #align order.is_succ_limit.succ_lt Order.IsSuccLimit.succ_lt
 
-/- warning: order.is_succ_limit.succ_lt_iff -> Order.IsSuccLimit.succ_lt_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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.succ_lt_iff Order.IsSuccLimit.succ_lt_iffₓ'. -/
 theorem IsSuccLimit.succ_lt_iff (hb : IsSuccLimit b) : succ a < b ↔ a < b :=
   ⟨fun h => (le_succ a).trans_lt h, hb.succ_lt⟩
 #align order.is_succ_limit.succ_lt_iff Order.IsSuccLimit.succ_lt_iff
 
-/- warning: order.is_succ_limit_iff_succ_lt -> Order.isSuccLimit_iff_succ_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)] {b : α}, Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) (forall (a : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (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)] {b : α}, Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) (forall (a : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b))
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff_succ_lt Order.isSuccLimit_iff_succ_ltₓ'. -/
 theorem isSuccLimit_iff_succ_lt : IsSuccLimit b ↔ ∀ a < b, succ a < b :=
   ⟨fun hb a => hb.succ_lt, isSuccLimit_of_succ_lt⟩
 #align order.is_succ_limit_iff_succ_lt Order.isSuccLimit_iff_succ_lt
 
-/- warning: order.is_succ_limit_rec_on -> Order.isSuccLimitRecOn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on Order.isSuccLimitRecOnₓ'. -/
 /-- A value can be built by building it on successors and successor limits. -/
 @[elab_as_elim]
 noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a))
@@ -281,23 +179,11 @@ noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a
     exact hs _ H.1
 #align order.is_succ_limit_rec_on Order.isSuccLimitRecOn
 
-/- warning: order.is_succ_limit_rec_on_limit -> Order.isSuccLimitRecOn_limit is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α} {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (hb : Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b), Eq.{u2} (C b) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C b hs hl) (hl b hb)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {b : α} {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (hb : Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b), Eq.{u1} (C b) (Order.isSuccLimitRecOn.{u2, u1} α _inst_1 _inst_2 C b hs hl) (hl b hb)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on_limit Order.isSuccLimitRecOn_limitₓ'. -/
 theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
     (hb : IsSuccLimit b) : @isSuccLimitRecOn α _ _ C b hs hl = hl b hb := by
   classical exact dif_pos hb
 #align order.is_succ_limit_rec_on_limit Order.isSuccLimitRecOn_limit
 
-/- warning: order.is_succ_limit_rec_on_succ' -> Order.isSuccLimitRecOn_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)] {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)), Eq.{u2} (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b hb)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b)), Eq.{u1} (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b hb)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on_succ' Order.isSuccLimitRecOn_succ'ₓ'. -/
 theorem isSuccLimitRecOn_succ' (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
     {b : α} (hb : ¬IsMax b) : @isSuccLimitRecOn α _ _ C (succ b) hs hl = hs b hb :=
   by
@@ -314,34 +200,16 @@ section NoMaxOrder
 
 variable [NoMaxOrder α]
 
-/- warning: order.is_succ_limit_rec_on_succ -> Order.isSuccLimitRecOn_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)] {C : α -> Sort.{u2}} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (b : α), Eq.{u2} (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMax.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 b))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} [_inst_3 : NoMaxOrder.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))] (hs : forall (a : α), (Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (b : α), Eq.{u1} (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMax.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 b))
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on_succ Order.isSuccLimitRecOn_succₓ'. -/
 @[simp]
 theorem isSuccLimitRecOn_succ (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a, IsSuccLimit a → C a)
     (b : α) : @isSuccLimitRecOn α _ _ C (succ b) hs hl = hs b (not_isMax b) :=
   isSuccLimitRecOn_succ' _ _ _
 #align order.is_succ_limit_rec_on_succ Order.isSuccLimitRecOn_succ
 
-/- warning: order.is_succ_limit_iff_succ_ne -> Order.isSuccLimit_iff_succ_ne 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 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall (b : α), Ne.{succ u1} α (Order.succ.{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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff_succ_ne Order.isSuccLimit_iff_succ_neₓ'. -/
 theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a :=
   ⟨IsSuccLimit.succ_ne, isSuccLimit_of_succ_ne⟩
 #align order.is_succ_limit_iff_succ_ne Order.isSuccLimit_iff_succ_ne
 
-/- warning: order.not_is_succ_limit_iff' -> Order.not_isSuccLimit_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 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.range.{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)] {a : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.range.{u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'ₓ'. -/
 theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) := by
   simp_rw [is_succ_limit_iff_succ_ne, not_forall, not_ne_iff]; rfl
 #align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'
@@ -352,12 +220,6 @@ section IsSuccArchimedean
 
 variable [IsSuccArchimedean α]
 
-/- warning: order.is_succ_limit.is_min -> Order.IsSuccLimit.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)] {a : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.is_min Order.IsSuccLimit.isMinₓ'. -/
 protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   by
   revert h
@@ -367,23 +229,11 @@ protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   exact H hc
 #align order.is_succ_limit.is_min Order.IsSuccLimit.isMin
 
-/- warning: order.is_succ_limit_iff -> Order.isSuccLimit_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 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff Order.isSuccLimit_iffₓ'. -/
 @[simp]
 theorem isSuccLimit_iff : IsSuccLimit a ↔ IsMin a :=
   ⟨IsSuccLimit.isMin, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff Order.isSuccLimit_iff
 
-/- warning: order.not_is_succ_limit -> Order.not_isSuccLimit 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 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{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 : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit Order.not_isSuccLimitₓ'. -/
 theorem not_isSuccLimit [NoMinOrder α] : ¬IsSuccLimit a := by simp
 #align order.not_is_succ_limit Order.not_isSuccLimit
 
@@ -445,44 +295,20 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-/- warning: is_max.is_pred_limit -> IsMax.isPredLimit is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align is_max.is_pred_limit IsMax.isPredLimitₓ'. -/
 protected theorem IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h b hab =>
   not_isMax_of_lt hab.lt h
 #align is_max.is_pred_limit IsMax.isPredLimit
 
-/- warning: order.is_pred_limit_top -> Order.isPredLimit_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)], Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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)], Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_top Order.isPredLimit_topₓ'. -/
 theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) :=
   isMax_top.IsPredLimit
 #align order.is_pred_limit_top Order.isPredLimit_top
 
 variable [PredOrder α]
 
-/- warning: order.is_pred_limit.is_min -> Order.IsPredLimit.isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (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.is_pred_limit.is_min Order.IsPredLimit.isMinₓ'. -/
 protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a := by by_contra H;
   exact h a (pred_covby_of_not_is_min H)
 #align order.is_pred_limit.is_min Order.IsPredLimit.isMin
 
-/- warning: order.not_is_pred_limit_pred_of_not_is_min -> Order.not_isPredLimit_pred_of_not_isMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a)))
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a)))
-Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_pred_of_not_is_min Order.not_isPredLimit_pred_of_not_isMinₓ'. -/
 theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) := by
   contrapose! ha; exact ha.is_min
 #align order.not_is_pred_limit_pred_of_not_is_min Order.not_isPredLimit_pred_of_not_isMin
@@ -491,22 +317,10 @@ section NoMinOrder
 
 variable [NoMinOrder α]
 
-/- warning: order.is_pred_limit.pred_ne -> Order.IsPredLimit.pred_ne is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2 b) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2 b) a)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.pred_ne Order.IsPredLimit.pred_neₓ'. -/
 theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a := by rintro rfl;
   exact not_isMin _ h.is_min
 #align order.is_pred_limit.pred_ne Order.IsPredLimit.pred_ne
 
-/- warning: order.not_is_pred_limit_pred -> Order.not_isPredLimit_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 : α), Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 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 : α), Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a))
-Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_pred Order.not_isPredLimit_predₓ'. -/
 @[simp]
 theorem not_isPredLimit_pred (a : α) : ¬IsPredLimit (pred a) := fun h => h.pred_ne _ rfl
 #align order.not_is_pred_limit_pred Order.not_isPredLimit_pred
@@ -517,33 +331,15 @@ section IsPredArchimedean
 
 variable [IsPredArchimedean α]
 
-/- warning: order.is_pred_limit.is_max_of_no_min -> Order.IsPredLimit.isMax_of_noMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.is_max_of_no_min Order.IsPredLimit.isMax_of_noMinₓ'. -/
 protected theorem IsPredLimit.isMax_of_noMin [NoMinOrder α] (h : IsPredLimit a) : IsMax a :=
   h.dual.isMin_of_noMax
 #align order.is_pred_limit.is_max_of_no_min Order.IsPredLimit.isMax_of_noMin
 
-/- warning: order.is_pred_limit_iff_of_no_min -> Order.isPredLimit_iff_of_noMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_iff_of_no_min Order.isPredLimit_iff_of_noMinₓ'. -/
 @[simp]
 theorem isPredLimit_iff_of_noMin [NoMinOrder α] : IsPredLimit a ↔ IsMax a :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff_of_noMax
 #align order.is_pred_limit_iff_of_no_min Order.isPredLimit_iff_of_noMin
 
-/- warning: order.not_is_pred_limit_of_no_min -> Order.not_isPredLimit_of_noMin is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
-Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_of_no_min Order.not_isPredLimit_of_noMinₓ'. -/
 theorem not_isPredLimit_of_noMin [NoMinOrder α] [NoMaxOrder α] : ¬IsPredLimit a := by simp
 #align order.not_is_pred_limit_of_no_min Order.not_isPredLimit_of_noMin
 
@@ -555,83 +351,35 @@ section PartialOrder
 
 variable [PartialOrder α] [PredOrder α] {a b : α} {C : α → Sort _}
 
-/- warning: order.is_pred_limit_of_pred_ne -> Order.isPredLimit_of_pred_ne 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 : α}, (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{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 : α}, (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_of_pred_ne Order.isPredLimit_of_pred_neₓ'. -/
 theorem isPredLimit_of_pred_ne (h : ∀ b, pred b ≠ a) : IsPredLimit a := fun b hba => h b hba.pred_eq
 #align order.is_pred_limit_of_pred_ne Order.isPredLimit_of_pred_ne
 
-/- warning: order.not_is_pred_limit_iff -> Order.not_isPredLimit_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 : α}, Iff (Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : α}, Iff (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)))
-Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_iff Order.not_isPredLimit_iffₓ'. -/
 theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a := by
   rw [← is_succ_limit_to_dual_iff]; exact not_is_succ_limit_iff
 #align order.not_is_pred_limit_iff Order.not_isPredLimit_iff
 
-/- warning: order.mem_range_pred_of_not_is_pred_limit -> Order.mem_range_pred_of_not_isPredLimit 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 (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.range.{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)] {a : α}, (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.range.{u1, succ u1} α α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)))
-Case conversion may be inaccurate. Consider using '#align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimitₓ'. -/
 /-- See `not_is_pred_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
 theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@pred α _ _) := by
   cases' not_is_pred_limit_iff.1 h with b hb; exact ⟨b, hb.2⟩
 #align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimit
 
-/- warning: order.is_pred_limit_of_pred_lt -> Order.isPredLimit_of_pred_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)] {b : α}, (forall (a : α), (GT.gt.{u1} α (Preorder.toHasLt.{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)) -> (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α}, (forall (a : α), (GT.gt.{u1} α (Preorder.toLT.{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)) -> (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_of_pred_lt Order.isPredLimit_of_pred_ltₓ'. -/
 theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b := fun a hab =>
   (H a hab.lt).Ne hab.pred_eq
 #align order.is_pred_limit_of_pred_lt Order.isPredLimit_of_pred_lt
 
-/- warning: order.is_pred_limit.lt_pred -> Order.IsPredLimit.lt_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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.lt_pred Order.IsPredLimit.lt_predₓ'. -/
 theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b :=
   h.dual.succ_lt
 #align order.is_pred_limit.lt_pred Order.IsPredLimit.lt_pred
 
-/- warning: order.is_pred_limit.lt_pred_iff -> Order.IsPredLimit.lt_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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.lt_pred_iff Order.IsPredLimit.lt_pred_iffₓ'. -/
 theorem IsPredLimit.lt_pred_iff (h : IsPredLimit a) : a < pred b ↔ a < b :=
   h.dual.succ_lt_iff
 #align order.is_pred_limit.lt_pred_iff Order.IsPredLimit.lt_pred_iff
 
-/- warning: order.is_pred_limit_iff_lt_pred -> Order.isPredLimit_iff_lt_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 : α}, Iff (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall {{b : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : α}, Iff (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall {{b : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)))
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_iff_lt_pred Order.isPredLimit_iff_lt_predₓ'. -/
 theorem isPredLimit_iff_lt_pred : IsPredLimit a ↔ ∀ ⦃b⦄, a < b → a < pred b :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff_succ_lt
 #align order.is_pred_limit_iff_lt_pred Order.isPredLimit_iff_lt_pred
 
-/- warning: order.is_pred_limit_rec_on -> Order.isPredLimitRecOn is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
-but is expected to have type
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on Order.isPredLimitRecOnₓ'. -/
 /-- A value can be built by building it on predecessors and predecessor limits. -/
 @[elab_as_elim]
 noncomputable def isPredLimitRecOn (b : α) (hs : ∀ a, ¬IsMin a → C (pred a))
@@ -639,23 +387,11 @@ noncomputable def isPredLimitRecOn (b : α) (hs : ∀ a, ¬IsMin a → C (pred a
   @isSuccLimitRecOn αᵒᵈ _ _ _ _ hs fun a ha => hl _ ha.dual
 #align order.is_pred_limit_rec_on Order.isPredLimitRecOn
 
-/- warning: order.is_pred_limit_rec_on_limit -> Order.isPredLimitRecOn_limit is a dubious translation:
-lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α} {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (hb : Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b), Eq.{u2} (C b) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C b hs hl) (hl b hb)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {b : α} {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (hb : Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b), Eq.{u1} (C b) (Order.isPredLimitRecOn.{u2, u1} α _inst_1 _inst_2 C b hs hl) (hl b hb)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on_limit Order.isPredLimitRecOn_limitₓ'. -/
 theorem isPredLimitRecOn_limit (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
     (hb : IsPredLimit b) : @isPredLimitRecOn α _ _ C b hs hl = hl b hb :=
   isSuccLimitRecOn_limit _ _ hb.dual
 #align order.is_pred_limit_rec_on_limit Order.isPredLimitRecOn_limit
 
-/- warning: order.is_pred_limit_rec_on_pred' -> Order.isPredLimitRecOn_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)] {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)), Eq.{u2} (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b hb)
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b)), Eq.{u1} (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b hb)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on_pred' Order.isPredLimitRecOn_pred'ₓ'. -/
 theorem isPredLimitRecOn_pred' (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
     {b : α} (hb : ¬IsMin b) : @isPredLimitRecOn α _ _ C (pred b) hs hl = hs b hb :=
   isSuccLimitRecOn_succ' _ _ _
@@ -665,12 +401,6 @@ section NoMinOrder
 
 variable [NoMinOrder α]
 
-/- warning: order.is_pred_limit_rec_on_pred -> Order.isPredLimitRecOn_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)] {C : α -> Sort.{u2}} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (b : α), Eq.{u2} (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMin.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 b))
-but is expected to have type
-  forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} [_inst_3 : NoMinOrder.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))] (hs : forall (a : α), (Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (b : α), Eq.{u1} (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMin.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 b))
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on_pred Order.isPredLimitRecOn_predₓ'. -/
 @[simp]
 theorem isPredLimitRecOn_pred (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀ a, IsPredLimit a → C a)
     (b : α) : @isPredLimitRecOn α _ _ C (pred b) hs hl = hs b (not_isMin b) :=
@@ -683,33 +413,15 @@ section IsPredArchimedean
 
 variable [IsPredArchimedean α]
 
-/- warning: order.is_pred_limit.is_max -> Order.IsPredLimit.isMax 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 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.is_max Order.IsPredLimit.isMaxₓ'. -/
 protected theorem IsPredLimit.isMax (h : IsPredLimit a) : IsMax a :=
   h.dual.IsMin
 #align order.is_pred_limit.is_max Order.IsPredLimit.isMax
 
-/- warning: order.is_pred_limit_iff -> Order.isPredLimit_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 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_iff Order.isPredLimit_iffₓ'. -/
 @[simp]
 theorem isPredLimit_iff : IsPredLimit a ↔ IsMax a :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff
 #align order.is_pred_limit_iff Order.isPredLimit_iff
 
-/- warning: order.not_is_pred_limit -> Order.not_isPredLimit 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 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{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 : α} [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
-Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit Order.not_isPredLimitₓ'. -/
 theorem not_isPredLimit [NoMaxOrder α] : ¬IsPredLimit a := by simp
 #align order.not_is_pred_limit Order.not_isPredLimit
 

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

@@ -96,9 +96,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
 Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.is_max Order.IsSuccLimit.isMaxₓ'. -/
-protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a :=
-  by
-  by_contra H
+protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a := by by_contra H;
   exact h a (covby_succ_of_not_is_max H)
 #align order.is_succ_limit.is_max Order.IsSuccLimit.isMax
 
@@ -108,10 +106,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)))
 Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_succ_of_not_is_max Order.not_isSuccLimit_succ_of_not_isMaxₓ'. -/
-theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) :=
-  by
-  contrapose! ha
-  exact ha.is_max
+theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) := by
+  contrapose! ha; exact ha.is_max
 #align order.not_is_succ_limit_succ_of_not_is_max Order.not_isSuccLimit_succ_of_not_isMax
 
 section NoMaxOrder
@@ -124,9 +120,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2 b) a)
 Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.succ_ne Order.IsSuccLimit.succ_neₓ'. -/
-theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a :=
-  by
-  rintro rfl
+theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a := by rintro rfl;
   exact not_isMax _ h.is_max
 #align order.is_succ_limit.succ_ne Order.IsSuccLimit.succ_ne
 
@@ -219,10 +213,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimitₓ'. -/
 /-- See `not_is_succ_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
-theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@succ α _ _) :=
-  by
-  cases' not_is_succ_limit_iff.1 h with b hb
-  exact ⟨b, hb.2⟩
+theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@succ α _ _) := by
+  cases' not_is_succ_limit_iff.1 h with b hb; exact ⟨b, hb.2⟩
 #align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimit
 
 /- warning: order.is_succ_limit_of_succ_lt -> Order.isSuccLimit_of_succ_lt is a dubious translation:
@@ -350,10 +342,8 @@ lean 3 declaration is
 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 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.range.{u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)))
 Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'ₓ'. -/
-theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) :=
-  by
-  simp_rw [is_succ_limit_iff_succ_ne, not_forall, not_ne_iff]
-  rfl
+theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) := by
+  simp_rw [is_succ_limit_iff_succ_ne, not_forall, not_ne_iff]; rfl
 #align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'
 
 end NoMaxOrder
@@ -483,9 +473,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (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.is_pred_limit.is_min Order.IsPredLimit.isMinₓ'. -/
-protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a :=
-  by
-  by_contra H
+protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a := by by_contra H;
   exact h a (pred_covby_of_not_is_min H)
 #align order.is_pred_limit.is_min Order.IsPredLimit.isMin
 
@@ -495,10 +483,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a)))
 Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_pred_of_not_is_min Order.not_isPredLimit_pred_of_not_isMinₓ'. -/
-theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) :=
-  by
-  contrapose! ha
-  exact ha.is_min
+theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) := by
+  contrapose! ha; exact ha.is_min
 #align order.not_is_pred_limit_pred_of_not_is_min Order.not_isPredLimit_pred_of_not_isMin
 
 section NoMinOrder
@@ -511,9 +497,7 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2 b) a)
 Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.pred_ne Order.IsPredLimit.pred_neₓ'. -/
-theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a :=
-  by
-  rintro rfl
+theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a := by rintro rfl;
   exact not_isMin _ h.is_min
 #align order.is_pred_limit.pred_ne Order.IsPredLimit.pred_ne
 
@@ -586,10 +570,8 @@ lean 3 declaration is
 but is expected to have type
   forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)))
 Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_iff Order.not_isPredLimit_iffₓ'. -/
-theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a :=
-  by
-  rw [← is_succ_limit_to_dual_iff]
-  exact not_is_succ_limit_iff
+theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a := by
+  rw [← is_succ_limit_to_dual_iff]; exact not_is_succ_limit_iff
 #align order.not_is_pred_limit_iff Order.not_isPredLimit_iff
 
 /- warning: order.mem_range_pred_of_not_is_pred_limit -> Order.mem_range_pred_of_not_isPredLimit is a dubious translation:
@@ -600,10 +582,8 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimitₓ'. -/
 /-- See `not_is_pred_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
-theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@pred α _ _) :=
-  by
-  cases' not_is_pred_limit_iff.1 h with b hb
-  exact ⟨b, hb.2⟩
+theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@pred α _ _) := by
+  cases' not_is_pred_limit_iff.1 h with b hb; exact ⟨b, hb.2⟩
 #align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimit
 
 /- warning: order.is_pred_limit_of_pred_lt -> Order.isPredLimit_of_pred_lt is a dubious translation:

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

@@ -68,15 +68,19 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-#print IsMin.isSuccLimit /-
+/- warning: is_min.is_succ_limit -> IsMin.isSuccLimit is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align is_min.is_succ_limit IsMin.isSuccLimitₓ'. -/
 protected theorem IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h b hab =>
   not_isMin_of_lt hab.lt h
 #align is_min.is_succ_limit IsMin.isSuccLimit
--/
 
 /- warning: order.is_succ_limit_bot -> Order.isSuccLimit_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)], Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (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)], Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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)], Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Bot.bot.{u1} α (OrderBot.toBot.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))
 Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_bot Order.isSuccLimit_botₓ'. -/
@@ -86,39 +90,55 @@ theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) :=
 
 variable [SuccOrder α]
 
-#print Order.IsSuccLimit.isMax /-
+/- warning: order.is_succ_limit.is_max -> Order.IsSuccLimit.isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.is_max Order.IsSuccLimit.isMaxₓ'. -/
 protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a :=
   by
   by_contra H
   exact h a (covby_succ_of_not_is_max H)
 #align order.is_succ_limit.is_max Order.IsSuccLimit.isMax
--/
 
-#print Order.not_isSuccLimit_succ_of_not_isMax /-
+/- warning: order.not_is_succ_limit_succ_of_not_is_max -> Order.not_isSuccLimit_succ_of_not_isMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1], (Not (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a)))
+Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_succ_of_not_is_max Order.not_isSuccLimit_succ_of_not_isMaxₓ'. -/
 theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) :=
   by
   contrapose! ha
   exact ha.is_max
 #align order.not_is_succ_limit_succ_of_not_is_max Order.not_isSuccLimit_succ_of_not_isMax
--/
 
 section NoMaxOrder
 
 variable [NoMaxOrder α]
 
-#print Order.IsSuccLimit.succ_ne /-
+/- warning: order.is_succ_limit.succ_ne -> Order.IsSuccLimit.succ_ne is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2 b) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α _inst_1 _inst_2 b) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.succ_ne Order.IsSuccLimit.succ_neₓ'. -/
 theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a :=
   by
   rintro rfl
   exact not_isMax _ h.is_max
 #align order.is_succ_limit.succ_ne Order.IsSuccLimit.succ_ne
--/
 
-#print Order.not_isSuccLimit_succ /-
+/- warning: order.not_is_succ_limit_succ -> Order.not_isSuccLimit_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 : α), Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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 : α), Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.succ.{u1} α _inst_1 _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_succ Order.not_isSuccLimit_succₓ'. -/
 @[simp]
 theorem not_isSuccLimit_succ (a : α) : ¬IsSuccLimit (succ a) := fun h => h.succ_ne _ rfl
 #align order.not_is_succ_limit_succ Order.not_isSuccLimit_succ
--/
 
 end NoMaxOrder
 
@@ -126,7 +146,12 @@ section IsSuccArchimedean
 
 variable [IsSuccArchimedean α]
 
-#print Order.IsSuccLimit.isMin_of_noMax /-
+/- warning: order.is_succ_limit.is_min_of_no_max -> Order.IsSuccLimit.isMin_of_noMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.is_min_of_no_max Order.IsSuccLimit.isMin_of_noMaxₓ'. -/
 theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a := fun b hb =>
   by
   rcases hb.exists_succ_iterate with ⟨_ | n, rfl⟩
@@ -134,19 +159,26 @@ theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a
   · rw [iterate_succ_apply'] at h
     exact (not_is_succ_limit_succ _ h).elim
 #align order.is_succ_limit.is_min_of_no_max Order.IsSuccLimit.isMin_of_noMax
--/
 
-#print Order.isSuccLimit_iff_of_noMax /-
+/- warning: order.is_succ_limit_iff_of_no_max -> Order.isSuccLimit_iff_of_noMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff_of_no_max Order.isSuccLimit_iff_of_noMaxₓ'. -/
 @[simp]
 theorem isSuccLimit_iff_of_noMax [NoMaxOrder α] : IsSuccLimit a ↔ IsMin a :=
   ⟨IsSuccLimit.isMin_of_noMax, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff_of_no_max Order.isSuccLimit_iff_of_noMax
--/
 
-#print Order.not_isSuccLimit_of_noMax /-
+/- warning: order.not_is_succ_limit_of_no_max -> Order.not_isSuccLimit_of_noMax is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : SuccOrder.{u1} α _inst_1] [_inst_3 : IsSuccArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_of_no_max Order.not_isSuccLimit_of_noMaxₓ'. -/
 theorem not_isSuccLimit_of_noMax [NoMinOrder α] [NoMaxOrder α] : ¬IsSuccLimit a := by simp
 #align order.not_is_succ_limit_of_no_max Order.not_isSuccLimit_of_noMax
--/
 
 end IsSuccArchimedean
 
@@ -156,12 +188,21 @@ section PartialOrder
 
 variable [PartialOrder α] [SuccOrder α] {a b : α} {C : α → Sort _}
 
-#print Order.isSuccLimit_of_succ_ne /-
+/- warning: order.is_succ_limit_of_succ_ne -> Order.isSuccLimit_of_succ_ne 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 : α}, (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{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 : α}, (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_of_succ_ne Order.isSuccLimit_of_succ_neₓ'. -/
 theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a := fun b hba => h b hba.succ_eq
 #align order.is_succ_limit_of_succ_ne Order.isSuccLimit_of_succ_ne
--/
 
-#print Order.not_isSuccLimit_iff /-
+/- warning: order.not_is_succ_limit_iff -> Order.not_isSuccLimit_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 : α}, Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) (Eq.{succ u1} α (Order.succ.{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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α}, Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) (Eq.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)))
+Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_iff Order.not_isSuccLimit_iffₓ'. -/
 theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a :=
   by
   rw [not_is_succ_limit_iff_exists_covby]
@@ -169,9 +210,13 @@ theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b =
   rintro ⟨h, rfl⟩
   exact covby_succ_of_not_is_max h
 #align order.not_is_succ_limit_iff Order.not_isSuccLimit_iff
--/
 
-#print Order.mem_range_succ_of_not_isSuccLimit /-
+/- warning: order.mem_range_succ_of_not_is_succ_limit -> Order.mem_range_succ_of_not_isSuccLimit 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 (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.range.{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)] {a : α}, (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.range.{u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)))
+Case conversion may be inaccurate. Consider using '#align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimitₓ'. -/
 /-- See `not_is_succ_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
 theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@succ α _ _) :=
@@ -179,15 +224,23 @@ theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@
   cases' not_is_succ_limit_iff.1 h with b hb
   exact ⟨b, hb.2⟩
 #align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimit
--/
 
-#print Order.isSuccLimit_of_succ_lt /-
+/- warning: order.is_succ_limit_of_succ_lt -> Order.isSuccLimit_of_succ_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)] {b : α}, (forall (a : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)) -> (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α}, (forall (a : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)) -> (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_of_succ_lt Order.isSuccLimit_of_succ_ltₓ'. -/
 theorem isSuccLimit_of_succ_lt (H : ∀ a < b, succ a < b) : IsSuccLimit b := fun a hab =>
   (H a hab.lt).Ne hab.succ_eq
 #align order.is_succ_limit_of_succ_lt Order.isSuccLimit_of_succ_lt
--/
 
-#print Order.IsSuccLimit.succ_lt /-
+/- warning: order.is_succ_limit.succ_lt -> Order.IsSuccLimit.succ_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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.succ_lt Order.IsSuccLimit.succ_ltₓ'. -/
 theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b :=
   by
   by_cases h : IsMax a
@@ -197,21 +250,33 @@ theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b :=
     subst hab
     exact (h hb.is_max).elim
 #align order.is_succ_limit.succ_lt Order.IsSuccLimit.succ_lt
--/
 
-#print Order.IsSuccLimit.succ_lt_iff /-
+/- warning: order.is_succ_limit.succ_lt_iff -> Order.IsSuccLimit.succ_lt_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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 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 : α}, (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.succ_lt_iff Order.IsSuccLimit.succ_lt_iffₓ'. -/
 theorem IsSuccLimit.succ_lt_iff (hb : IsSuccLimit b) : succ a < b ↔ a < b :=
   ⟨fun h => (le_succ a).trans_lt h, hb.succ_lt⟩
 #align order.is_succ_limit.succ_lt_iff Order.IsSuccLimit.succ_lt_iff
--/
 
-#print Order.isSuccLimit_iff_succ_lt /-
+/- warning: order.is_succ_limit_iff_succ_lt -> Order.isSuccLimit_iff_succ_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)] {b : α}, Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) (forall (a : α), (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (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)] {b : α}, Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b) (forall (a : α), (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a) b))
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff_succ_lt Order.isSuccLimit_iff_succ_ltₓ'. -/
 theorem isSuccLimit_iff_succ_lt : IsSuccLimit b ↔ ∀ a < b, succ a < b :=
   ⟨fun hb a => hb.succ_lt, isSuccLimit_of_succ_lt⟩
 #align order.is_succ_limit_iff_succ_lt Order.isSuccLimit_iff_succ_lt
--/
 
-#print Order.isSuccLimitRecOn /-
+/- warning: order.is_succ_limit_rec_on -> Order.isSuccLimitRecOn is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on Order.isSuccLimitRecOnₓ'. -/
 /-- A value can be built by building it on successors and successor limits. -/
 @[elab_as_elim]
 noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a))
@@ -223,11 +288,10 @@ noncomputable def isSuccLimitRecOn (b : α) (hs : ∀ a, ¬IsMax a → C (succ a
     rw [← H.2]
     exact hs _ H.1
 #align order.is_succ_limit_rec_on Order.isSuccLimitRecOn
--/
 
 /- warning: order.is_succ_limit_rec_on_limit -> Order.isSuccLimitRecOn_limit is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α} {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (hb : Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b), Eq.{u2} (C b) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C b hs hl) (hl b hb)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α} {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (hb : Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b), Eq.{u2} (C b) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C b hs hl) (hl b hb)
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {b : α} {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (hb : Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b), Eq.{u1} (C b) (Order.isSuccLimitRecOn.{u2, u1} α _inst_1 _inst_2 C b hs hl) (hl b hb)
 Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on_limit Order.isSuccLimitRecOn_limitₓ'. -/
@@ -238,7 +302,7 @@ theorem isSuccLimitRecOn_limit (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀
 
 /- warning: order.is_succ_limit_rec_on_succ' -> Order.isSuccLimitRecOn_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)] {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)), Eq.{u2} (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b hb)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)), Eq.{u2} (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b hb)
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b)), Eq.{u1} (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b hb)
 Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on_succ' Order.isSuccLimitRecOn_succ'ₓ'. -/
@@ -260,7 +324,7 @@ variable [NoMaxOrder α]
 
 /- warning: order.is_succ_limit_rec_on_succ -> Order.isSuccLimitRecOn_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)] {C : α -> Sort.{u2}} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (b : α), Eq.{u2} (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMax.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 b))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (hs : forall (a : α), (Not (IsMax.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (b : α), Eq.{u2} (C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMax.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 b))
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : SuccOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} [_inst_3 : NoMaxOrder.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))] (hs : forall (a : α), (Not (IsMax.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsSuccLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (b : α), Eq.{u1} (C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isSuccLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.succ.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMax.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 b))
 Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_rec_on_succ Order.isSuccLimitRecOn_succₓ'. -/
@@ -270,19 +334,27 @@ theorem isSuccLimitRecOn_succ (hs : ∀ a, ¬IsMax a → C (succ a)) (hl : ∀ a
   isSuccLimitRecOn_succ' _ _ _
 #align order.is_succ_limit_rec_on_succ Order.isSuccLimitRecOn_succ
 
-#print Order.isSuccLimit_iff_succ_ne /-
+/- warning: order.is_succ_limit_iff_succ_ne -> Order.isSuccLimit_iff_succ_ne 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 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall (b : α), Ne.{succ u1} α (Order.succ.{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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall (b : α), Ne.{succ u1} α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff_succ_ne Order.isSuccLimit_iff_succ_neₓ'. -/
 theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a :=
   ⟨IsSuccLimit.succ_ne, isSuccLimit_of_succ_ne⟩
 #align order.is_succ_limit_iff_succ_ne Order.isSuccLimit_iff_succ_ne
--/
 
-#print Order.not_isSuccLimit_iff' /-
+/- warning: order.not_is_succ_limit_iff' -> Order.not_isSuccLimit_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 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.range.{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)] {a : α} [_inst_3 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Iff (Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.range.{u1, succ u1} α α (Order.succ.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)))
+Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'ₓ'. -/
 theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) :=
   by
   simp_rw [is_succ_limit_iff_succ_ne, not_forall, not_ne_iff]
   rfl
 #align order.not_is_succ_limit_iff' Order.not_isSuccLimit_iff'
--/
 
 end NoMaxOrder
 
@@ -290,7 +362,12 @@ section IsSuccArchimedean
 
 variable [IsSuccArchimedean α]
 
-#print Order.IsSuccLimit.isMin /-
+/- warning: order.is_succ_limit.is_min -> Order.IsSuccLimit.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)] {a : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit.is_min Order.IsSuccLimit.isMinₓ'. -/
 protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   by
   revert h
@@ -299,19 +376,26 @@ protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   rw [this] at hc⊢
   exact H hc
 #align order.is_succ_limit.is_min Order.IsSuccLimit.isMin
--/
 
-#print Order.isSuccLimit_iff /-
+/- warning: order.is_succ_limit_iff -> Order.isSuccLimit_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 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : SuccOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.is_succ_limit_iff Order.isSuccLimit_iffₓ'. -/
 @[simp]
 theorem isSuccLimit_iff : IsSuccLimit a ↔ IsMin a :=
   ⟨IsSuccLimit.isMin, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff Order.isSuccLimit_iff
--/
 
-#print Order.not_isSuccLimit /-
+/- warning: order.not_is_succ_limit -> Order.not_isSuccLimit 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 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsSuccLimit.{u1} α (Preorder.toHasLt.{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 : α} [_inst_3 : IsSuccArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsSuccLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.not_is_succ_limit Order.not_isSuccLimitₓ'. -/
 theorem not_isSuccLimit [NoMinOrder α] : ¬IsSuccLimit a := by simp
 #align order.not_is_succ_limit Order.not_isSuccLimit
--/
 
 end IsSuccArchimedean
 
@@ -371,15 +455,19 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-#print IsMax.isPredLimit /-
+/- warning: is_max.is_pred_limit -> IsMax.isPredLimit is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a) -> (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α}, (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a) -> (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align is_max.is_pred_limit IsMax.isPredLimitₓ'. -/
 protected theorem IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h b hab =>
   not_isMax_of_lt hab.lt h
 #align is_max.is_pred_limit IsMax.isPredLimit
--/
 
 /- warning: order.is_pred_limit_top -> Order.isPredLimit_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)], Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (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)], Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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)], Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Top.top.{u1} α (OrderTop.toTop.{u1} α (Preorder.toLE.{u1} α _inst_1) _inst_2))
 Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_top Order.isPredLimit_topₓ'. -/
@@ -389,39 +477,55 @@ theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) :=
 
 variable [PredOrder α]
 
-#print Order.IsPredLimit.isMin /-
+/- warning: order.is_pred_limit.is_min -> Order.IsPredLimit.isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (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} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (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.is_pred_limit.is_min Order.IsPredLimit.isMinₓ'. -/
 protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a :=
   by
   by_contra H
   exact h a (pred_covby_of_not_is_min H)
 #align order.is_pred_limit.is_min Order.IsPredLimit.isMin
--/
 
-#print Order.not_isPredLimit_pred_of_not_isMin /-
+/- warning: order.not_is_pred_limit_pred_of_not_is_min -> Order.not_isPredLimit_pred_of_not_isMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)) -> (Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a)))
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1], (Not (IsMin.{u1} α (Preorder.toLE.{u1} α _inst_1) a)) -> (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a)))
+Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_pred_of_not_is_min Order.not_isPredLimit_pred_of_not_isMinₓ'. -/
 theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) :=
   by
   contrapose! ha
   exact ha.is_min
 #align order.not_is_pred_limit_pred_of_not_is_min Order.not_isPredLimit_pred_of_not_isMin
--/
 
 section NoMinOrder
 
 variable [NoMinOrder α]
 
-#print Order.IsPredLimit.pred_ne /-
+/- warning: order.is_pred_limit.pred_ne -> Order.IsPredLimit.pred_ne is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2 b) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α _inst_1 _inst_2 b) a)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.pred_ne Order.IsPredLimit.pred_neₓ'. -/
 theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a :=
   by
   rintro rfl
   exact not_isMin _ h.is_min
 #align order.is_pred_limit.pred_ne Order.IsPredLimit.pred_ne
--/
 
-#print Order.not_isPredLimit_pred /-
+/- warning: order.not_is_pred_limit_pred -> Order.not_isPredLimit_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 : α), Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 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 : α), Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) (Order.pred.{u1} α _inst_1 _inst_2 a))
+Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_pred Order.not_isPredLimit_predₓ'. -/
 @[simp]
 theorem not_isPredLimit_pred (a : α) : ¬IsPredLimit (pred a) := fun h => h.pred_ne _ rfl
 #align order.not_is_pred_limit_pred Order.not_isPredLimit_pred
--/
 
 end NoMinOrder
 
@@ -429,23 +533,35 @@ section IsPredArchimedean
 
 variable [IsPredArchimedean α]
 
-#print Order.IsPredLimit.isMax_of_noMin /-
+/- warning: order.is_pred_limit.is_max_of_no_min -> Order.IsPredLimit.isMax_of_noMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) -> (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) -> (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.is_max_of_no_min Order.IsPredLimit.isMax_of_noMinₓ'. -/
 protected theorem IsPredLimit.isMax_of_noMin [NoMinOrder α] (h : IsPredLimit a) : IsMax a :=
   h.dual.isMin_of_noMax
 #align order.is_pred_limit.is_max_of_no_min Order.IsPredLimit.isMax_of_noMin
--/
 
-#print Order.isPredLimit_iff_of_noMin /-
+/- warning: order.is_pred_limit_iff_of_no_min -> Order.isPredLimit_iff_of_noMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Iff (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a) (IsMax.{u1} α (Preorder.toHasLe.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Iff (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a) (IsMax.{u1} α (Preorder.toLE.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_iff_of_no_min Order.isPredLimit_iff_of_noMinₓ'. -/
 @[simp]
 theorem isPredLimit_iff_of_noMin [NoMinOrder α] : IsPredLimit a ↔ IsMax a :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff_of_noMax
 #align order.is_pred_limit_iff_of_no_min Order.isPredLimit_iff_of_noMin
--/
 
-#print Order.not_isPredLimit_of_noMin /-
+/- warning: order.not_is_pred_limit_of_no_min -> Order.not_isPredLimit_of_noMin is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α _inst_1)], Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α _inst_1) a)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : Preorder.{u1} α] {a : α} [_inst_2 : PredOrder.{u1} α _inst_1] [_inst_3 : IsPredArchimedean.{u1} α _inst_1 _inst_2] [_inst_4 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)] [_inst_5 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α _inst_1)], Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α _inst_1) a)
+Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_of_no_min Order.not_isPredLimit_of_noMinₓ'. -/
 theorem not_isPredLimit_of_noMin [NoMinOrder α] [NoMaxOrder α] : ¬IsPredLimit a := by simp
 #align order.not_is_pred_limit_of_no_min Order.not_isPredLimit_of_noMin
--/
 
 end IsPredArchimedean
 
@@ -455,20 +571,33 @@ section PartialOrder
 
 variable [PartialOrder α] [PredOrder α] {a b : α} {C : α → Sort _}
 
-#print Order.isPredLimit_of_pred_ne /-
+/- warning: order.is_pred_limit_of_pred_ne -> Order.isPredLimit_of_pred_ne 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 : α}, (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{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 : α}, (forall (b : α), Ne.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a) -> (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_of_pred_ne Order.isPredLimit_of_pred_neₓ'. -/
 theorem isPredLimit_of_pred_ne (h : ∀ b, pred b ≠ a) : IsPredLimit a := fun b hba => h b hba.pred_eq
 #align order.is_pred_limit_of_pred_ne Order.isPredLimit_of_pred_ne
--/
 
-#print Order.not_isPredLimit_iff /-
+/- warning: order.not_is_pred_limit_iff -> Order.not_isPredLimit_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 : α}, Iff (Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : α}, Iff (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) (Exists.{succ u1} α (fun (b : α) => And (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)) (Eq.{succ u1} α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) a)))
+Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit_iff Order.not_isPredLimit_iffₓ'. -/
 theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a :=
   by
   rw [← is_succ_limit_to_dual_iff]
   exact not_is_succ_limit_iff
 #align order.not_is_pred_limit_iff Order.not_isPredLimit_iff
--/
 
-#print Order.mem_range_pred_of_not_isPredLimit /-
+/- warning: order.mem_range_pred_of_not_is_pred_limit -> Order.mem_range_pred_of_not_isPredLimit 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 (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.Mem.{u1, u1} α (Set.{u1} α) (Set.hasMem.{u1} α) a (Set.range.{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)] {a : α}, (Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (Membership.mem.{u1, u1} α (Set.{u1} α) (Set.instMembershipSet.{u1} α) a (Set.range.{u1, succ u1} α α (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2)))
+Case conversion may be inaccurate. Consider using '#align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimitₓ'. -/
 /-- See `not_is_pred_limit_iff` for a version that states that `a` is a successor of a value other
 than itself. -/
 theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@pred α _ _) :=
@@ -476,44 +605,63 @@ theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@
   cases' not_is_pred_limit_iff.1 h with b hb
   exact ⟨b, hb.2⟩
 #align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimit
--/
 
-#print Order.isPredLimit_of_pred_lt /-
+/- warning: order.is_pred_limit_of_pred_lt -> Order.isPredLimit_of_pred_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)] {b : α}, (forall (a : α), (GT.gt.{u1} α (Preorder.toHasLt.{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)) -> (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α}, (forall (a : α), (GT.gt.{u1} α (Preorder.toLT.{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)) -> (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_of_pred_lt Order.isPredLimit_of_pred_ltₓ'. -/
 theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b := fun a hab =>
   (H a hab.lt).Ne hab.pred_eq
 #align order.is_pred_limit_of_pred_lt Order.isPredLimit_of_pred_lt
--/
 
-#print Order.IsPredLimit.lt_pred /-
+/- warning: order.is_pred_limit.lt_pred -> Order.IsPredLimit.lt_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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b))
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.lt_pred Order.IsPredLimit.lt_predₓ'. -/
 theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b :=
   h.dual.succ_lt
 #align order.is_pred_limit.lt_pred Order.IsPredLimit.lt_pred
--/
 
-#print Order.IsPredLimit.lt_pred_iff /-
+/- warning: order.is_pred_limit.lt_pred_iff -> Order.IsPredLimit.lt_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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Iff (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 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 : α}, (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (Iff (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b))
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.lt_pred_iff Order.IsPredLimit.lt_pred_iffₓ'. -/
 theorem IsPredLimit.lt_pred_iff (h : IsPredLimit a) : a < pred b ↔ a < b :=
   h.dual.succ_lt_iff
 #align order.is_pred_limit.lt_pred_iff Order.IsPredLimit.lt_pred_iff
--/
 
-#print Order.isPredLimit_iff_lt_pred /-
+/- warning: order.is_pred_limit_iff_lt_pred -> Order.isPredLimit_iff_lt_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 : α}, Iff (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall {{b : α}}, (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : α}, Iff (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (forall {{b : α}}, (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a b) -> (LT.lt.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)))
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_iff_lt_pred Order.isPredLimit_iff_lt_predₓ'. -/
 theorem isPredLimit_iff_lt_pred : IsPredLimit a ↔ ∀ ⦃b⦄, a < b → a < pred b :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff_succ_lt
 #align order.is_pred_limit_iff_lt_pred Order.isPredLimit_iff_lt_pred
--/
 
-#print Order.isPredLimitRecOn /-
+/- warning: order.is_pred_limit_rec_on -> Order.isPredLimitRecOn is a dubious translation:
+lean 3 declaration is
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
+but is expected to have type
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (b : α), (forall (a : α), (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) -> (forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) -> (C b)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on Order.isPredLimitRecOnₓ'. -/
 /-- A value can be built by building it on predecessors and predecessor limits. -/
 @[elab_as_elim]
 noncomputable def isPredLimitRecOn (b : α) (hs : ∀ a, ¬IsMin a → C (pred a))
     (hl : ∀ a, IsPredLimit a → C a) : C b :=
   @isSuccLimitRecOn αᵒᵈ _ _ _ _ hs fun a ha => hl _ ha.dual
 #align order.is_pred_limit_rec_on Order.isPredLimitRecOn
--/
 
 /- warning: order.is_pred_limit_rec_on_limit -> Order.isPredLimitRecOn_limit is a dubious translation:
 lean 3 declaration is
-  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α} {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (hb : Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b), Eq.{u2} (C b) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C b hs hl) (hl b hb)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {b : α} {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (hb : Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b), Eq.{u2} (C b) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C b hs hl) (hl b hb)
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {b : α} {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (hb : Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b), Eq.{u1} (C b) (Order.isPredLimitRecOn.{u2, u1} α _inst_1 _inst_2 C b hs hl) (hl b hb)
 Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on_limit Order.isPredLimitRecOn_limitₓ'. -/
@@ -524,7 +672,7 @@ theorem isPredLimitRecOn_limit (hs : ∀ a, ¬IsMin a → C (pred a)) (hl : ∀
 
 /- warning: order.is_pred_limit_rec_on_pred' -> Order.isPredLimitRecOn_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)] {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)), Eq.{u2} (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b hb)
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) b)), Eq.{u2} (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b hb)
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} (hs : forall (a : α), (Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) {b : α} (hb : Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) b)), Eq.{u1} (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b hb)
 Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on_pred' Order.isPredLimitRecOn_pred'ₓ'. -/
@@ -539,7 +687,7 @@ variable [NoMinOrder α]
 
 /- warning: order.is_pred_limit_rec_on_pred -> Order.isPredLimitRecOn_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)] {C : α -> Sort.{u2}} [_inst_3 : NoMinOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (b : α), Eq.{u2} (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMin.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 b))
+  forall {α : Type.{u1}} [_inst_1 : PartialOrder.{u1} α] [_inst_2 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {C : α -> Sort.{u2}} [_inst_3 : NoMinOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))] (hs : forall (a : α), (Not (IsMin.{u1} α (Preorder.toHasLe.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)) -> (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (C a)) (b : α), Eq.{u2} (C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u1, u2} α _inst_1 _inst_2 C (Order.pred.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMin.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_3 b))
 but is expected to have type
   forall {α : Type.{u2}} [_inst_1 : PartialOrder.{u2} α] [_inst_2 : PredOrder.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)] {C : α -> Sort.{u1}} [_inst_3 : NoMinOrder.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1))] (hs : forall (a : α), (Not (IsMin.{u2} α (Preorder.toLE.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a)) -> (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 a))) (hl : forall (a : α), (Order.IsPredLimit.{u2} α (Preorder.toLT.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1)) a) -> (C a)) (b : α), Eq.{u1} (C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b)) (Order.isPredLimitRecOn.{u2, u1} α _inst_1 _inst_2 C (Order.pred.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_2 b) hs hl) (hs b (not_isMin.{u2} α (PartialOrder.toPreorder.{u2} α _inst_1) _inst_3 b))
 Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_rec_on_pred Order.isPredLimitRecOn_predₓ'. -/
@@ -555,23 +703,35 @@ section IsPredArchimedean
 
 variable [IsPredArchimedean α]
 
-#print Order.IsPredLimit.isMax /-
+/- warning: order.is_pred_limit.is_max -> Order.IsPredLimit.isMax 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 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) -> (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit.is_max Order.IsPredLimit.isMaxₓ'. -/
 protected theorem IsPredLimit.isMax (h : IsPredLimit a) : IsMax a :=
   h.dual.IsMin
 #align order.is_pred_limit.is_max Order.IsPredLimit.isMax
--/
 
-#print Order.isPredLimit_iff /-
+/- warning: order.is_pred_limit_iff -> Order.isPredLimit_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 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) 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 : PredOrder.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)] {a : α} [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2], Iff (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a) (IsMax.{u1} α (Preorder.toLE.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.is_pred_limit_iff Order.isPredLimit_iffₓ'. -/
 @[simp]
 theorem isPredLimit_iff : IsPredLimit a ↔ IsMax a :=
   isSuccLimit_toDual_iff.symm.trans isSuccLimit_iff
 #align order.is_pred_limit_iff Order.isPredLimit_iff
--/
 
-#print Order.not_isPredLimit /-
+/- warning: order.not_is_pred_limit -> Order.not_isPredLimit 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 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toHasLt.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsPredLimit.{u1} α (Preorder.toHasLt.{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 : α} [_inst_3 : IsPredArchimedean.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1) _inst_2] [_inst_4 : NoMaxOrder.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1))], Not (Order.IsPredLimit.{u1} α (Preorder.toLT.{u1} α (PartialOrder.toPreorder.{u1} α _inst_1)) a)
+Case conversion may be inaccurate. Consider using '#align order.not_is_pred_limit Order.not_isPredLimitₓ'. -/
 theorem not_isPredLimit [NoMaxOrder α] : ¬IsPredLimit a := by simp
 #align order.not_is_pred_limit Order.not_isPredLimit
--/
 
 end IsPredArchimedean
 

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

@@ -68,10 +68,10 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-#print Order.IsMin.isSuccLimit /-
-protected theorem Order.IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h b hab =>
+#print IsMin.isSuccLimit /-
+protected theorem IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h b hab =>
   not_isMin_of_lt hab.lt h
-#align is_min.is_succ_limit Order.IsMin.isSuccLimit
+#align is_min.is_succ_limit IsMin.isSuccLimit
 -/
 
 /- warning: order.is_succ_limit_bot -> Order.isSuccLimit_bot is a dubious translation:
@@ -139,7 +139,7 @@ theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a
 #print Order.isSuccLimit_iff_of_noMax /-
 @[simp]
 theorem isSuccLimit_iff_of_noMax [NoMaxOrder α] : IsSuccLimit a ↔ IsMin a :=
-  ⟨IsSuccLimit.isMin_of_noMax, Order.IsMin.isSuccLimit⟩
+  ⟨IsSuccLimit.isMin_of_noMax, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff_of_no_max Order.isSuccLimit_iff_of_noMax
 -/
 
@@ -304,7 +304,7 @@ protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
 #print Order.isSuccLimit_iff /-
 @[simp]
 theorem isSuccLimit_iff : IsSuccLimit a ↔ IsMin a :=
-  ⟨IsSuccLimit.isMin, Order.IsMin.isSuccLimit⟩
+  ⟨IsSuccLimit.isMin, IsMin.isSuccLimit⟩
 #align order.is_succ_limit_iff Order.isSuccLimit_iff
 -/
 
@@ -371,10 +371,10 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-#print Order.IsMax.isPredLimit /-
-protected theorem Order.IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h b hab =>
+#print IsMax.isPredLimit /-
+protected theorem IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h b hab =>
   not_isMax_of_lt hab.lt h
-#align is_max.is_pred_limit Order.IsMax.isPredLimit
+#align is_max.is_pred_limit IsMax.isPredLimit
 -/
 
 /- warning: order.is_pred_limit_top -> Order.isPredLimit_top is a dubious translation:

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

Rename

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

@@ -43,12 +43,12 @@ def IsSuccLimit (a : α) : Prop :=
   ∀ b, ¬b ⋖ a
 #align order.is_succ_limit Order.IsSuccLimit
 
-theorem not_isSuccLimit_iff_exists_covby (a : α) : ¬IsSuccLimit a ↔ ∃ b, b ⋖ a := by
+theorem not_isSuccLimit_iff_exists_covBy (a : α) : ¬IsSuccLimit a ↔ ∃ b, b ⋖ a := by
   simp [IsSuccLimit]
-#align order.not_is_succ_limit_iff_exists_covby Order.not_isSuccLimit_iff_exists_covby
+#align order.not_is_succ_limit_iff_exists_covby Order.not_isSuccLimit_iff_exists_covBy
 
 @[simp]
-theorem isSuccLimit_of_dense [DenselyOrdered α] (a : α) : IsSuccLimit a := fun _ => not_covby
+theorem isSuccLimit_of_dense [DenselyOrdered α] (a : α) : IsSuccLimit a := fun _ => not_covBy
 #align order.is_succ_limit_of_dense Order.isSuccLimit_of_dense
 
 end LT
@@ -69,7 +69,7 @@ variable [SuccOrder α]
 
 protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a := by
   by_contra H
-  exact h a (covby_succ_of_not_isMax H)
+  exact h a (covBy_succ_of_not_isMax H)
 #align order.is_succ_limit.is_max Order.IsSuccLimit.isMax
 
 theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) := by
@@ -120,14 +120,14 @@ section PartialOrder
 variable [PartialOrder α] [SuccOrder α] {a b : α} {C : α → Sort*}
 
 theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a := fun b hba =>
-  h b (Covby.succ_eq hba)
+  h b (CovBy.succ_eq hba)
 #align order.is_succ_limit_of_succ_ne Order.isSuccLimit_of_succ_ne
 
 theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a := by
-  rw [not_isSuccLimit_iff_exists_covby]
-  refine' exists_congr fun b => ⟨fun hba => ⟨hba.lt.not_isMax, (Covby.succ_eq hba)⟩, _⟩
+  rw [not_isSuccLimit_iff_exists_covBy]
+  refine' exists_congr fun b => ⟨fun hba => ⟨hba.lt.not_isMax, (CovBy.succ_eq hba)⟩, _⟩
   rintro ⟨h, rfl⟩
-  exact covby_succ_of_not_isMax h
+  exact covBy_succ_of_not_isMax h
 #align order.not_is_succ_limit_iff Order.not_isSuccLimit_iff
 
 /-- See `not_isSuccLimit_iff` for a version that states that `a` is a successor of a value other
@@ -138,7 +138,7 @@ theorem mem_range_succ_of_not_isSuccLimit (h : ¬IsSuccLimit a) : a ∈ range (@
 #align order.mem_range_succ_of_not_is_succ_limit Order.mem_range_succ_of_not_isSuccLimit
 
 theorem isSuccLimit_of_succ_lt (H : ∀ a < b, succ a < b) : IsSuccLimit b := fun a hab =>
-  (H a hab.lt).ne (Covby.succ_eq hab)
+  (H a hab.lt).ne (CovBy.succ_eq hab)
 #align order.is_succ_limit_of_succ_lt Order.isSuccLimit_of_succ_lt
 
 theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b := by
@@ -245,11 +245,11 @@ def IsPredLimit (a : α) : Prop :=
   ∀ b, ¬a ⋖ b
 #align order.is_pred_limit Order.IsPredLimit
 
-theorem not_isPredLimit_iff_exists_covby (a : α) : ¬IsPredLimit a ↔ ∃ b, a ⋖ b := by
+theorem not_isPredLimit_iff_exists_covBy (a : α) : ¬IsPredLimit a ↔ ∃ b, a ⋖ b := by
   simp [IsPredLimit]
-#align order.not_is_pred_limit_iff_exists_covby Order.not_isPredLimit_iff_exists_covby
+#align order.not_is_pred_limit_iff_exists_covby Order.not_isPredLimit_iff_exists_covBy
 
-theorem isPredLimit_of_dense [DenselyOrdered α] (a : α) : IsPredLimit a := fun _ => not_covby
+theorem isPredLimit_of_dense [DenselyOrdered α] (a : α) : IsPredLimit a := fun _ => not_covBy
 #align order.is_pred_limit_of_dense Order.isPredLimit_of_dense
 
 @[simp]
@@ -286,7 +286,7 @@ variable [PredOrder α]
 
 protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a := by
   by_contra H
-  exact h a (pred_covby_of_not_isMin H)
+  exact h a (pred_covBy_of_not_isMin H)
 #align order.is_pred_limit.is_min Order.IsPredLimit.isMin
 
 theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) := by
@@ -334,7 +334,7 @@ section PartialOrder
 variable [PartialOrder α] [PredOrder α] {a b : α} {C : α → Sort*}
 
 theorem isPredLimit_of_pred_ne (h : ∀ b, pred b ≠ a) : IsPredLimit a := fun b hba =>
-  h b (Covby.pred_eq hba)
+  h b (CovBy.pred_eq hba)
 #align order.is_pred_limit_of_pred_ne Order.isPredLimit_of_pred_ne
 
 theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a := by
@@ -350,7 +350,7 @@ theorem mem_range_pred_of_not_isPredLimit (h : ¬IsPredLimit a) : a ∈ range (@
 #align order.mem_range_pred_of_not_is_pred_limit Order.mem_range_pred_of_not_isPredLimit
 
 theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b := fun a hab =>
-  (H a hab.lt).ne (Covby.pred_eq hab)
+  (H a hab.lt).ne (CovBy.pred_eq hab)
 #align order.is_pred_limit_of_pred_lt Order.isPredLimit_of_pred_lt
 
 theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b :=

@@ -262,10 +262,10 @@ theorem isPredLimit_toDual_iff : IsPredLimit (toDual a) ↔ IsSuccLimit a := by
   simp [IsSuccLimit, IsPredLimit]
 #align order.is_pred_limit_to_dual_iff Order.isPredLimit_toDual_iff
 
-alias isSuccLimit_toDual_iff ↔ _ isPredLimit.dual
+alias ⟨_, isPredLimit.dual⟩ := isSuccLimit_toDual_iff
 #align order.is_pred_limit.dual Order.isPredLimit.dual
 
-alias isPredLimit_toDual_iff ↔ _ isSuccLimit.dual
+alias ⟨_, isSuccLimit.dual⟩ := isPredLimit_toDual_iff
 #align order.is_succ_limit.dual Order.isSuccLimit.dual
 
 end LT

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

This has nice performance benefits.

@@ -22,7 +22,7 @@ predicate `Order.IsSuccLimit`.
 -/
 
 
-variable {α : Type _}
+variable {α : Type*}
 
 namespace Order
 
@@ -117,7 +117,7 @@ end Preorder
 
 section PartialOrder
 
-variable [PartialOrder α] [SuccOrder α] {a b : α} {C : α → Sort _}
+variable [PartialOrder α] [SuccOrder α] {a b : α} {C : α → Sort*}
 
 theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a := fun b hba =>
   h b (Covby.succ_eq hba)
@@ -331,7 +331,7 @@ end Preorder
 
 section PartialOrder
 
-variable [PartialOrder α] [PredOrder α] {a b : α} {C : α → Sort _}
+variable [PartialOrder α] [PredOrder α] {a b : α} {C : α → Sort*}
 
 theorem isPredLimit_of_pred_ne (h : ∀ b, pred b ≠ a) : IsPredLimit a := fun b hba =>
   h b (Covby.pred_eq hba)

• depends on: #5966

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

@@ -2,15 +2,12 @@
 Copyright (c) 2022 Violeta Hernández Palacios. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Violeta Hernández Palacios
-
-! This file was ported from Lean 3 source module order.succ_pred.limit
-! leanprover-community/mathlib commit 1e05171a5e8cf18d98d9cf7b207540acb044acae
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Order.SuccPred.Basic
 import Mathlib.Order.BoundedOrder
 
+#align_import order.succ_pred.limit from "leanprover-community/mathlib"@"1e05171a5e8cf18d98d9cf7b207540acb044acae"
+
 /-!
 # Successor and predecessor limits
 

Changes are of the form

• some_tactic at h⊢ -> some_tactic at h ⊢
• some_tactic at h -> some_tactic at h

@@ -217,7 +217,7 @@ protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a := fun b hb =>
   revert h
   refine' Succ.rec (fun _ => le_rfl) (fun c _ H hc => _) hb
   have := hc.isMax.succ_eq
-  rw [this] at hc⊢
+  rw [this] at hc ⊢
   exact H hc
 #align order.is_succ_limit.is_min Order.IsSuccLimit.isMin
 

Mathport doesn't understand this, and apparently nor do many of the humans fixing the errors it creates.

If your #align statement complains the def doesn't exist, don't change the #align; work out why it doesn't exist instead.

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

@@ -60,9 +60,9 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-protected theorem IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h _ hab =>
+protected theorem _root_.IsMin.isSuccLimit : IsMin a → IsSuccLimit a := fun h _ hab =>
   not_isMin_of_lt hab.lt h
-#align is_min.is_succ_limit Order.IsMin.isSuccLimit
+#align is_min.is_succ_limit IsMin.isSuccLimit
 
 theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) :=
   IsMin.isSuccLimit isMin_bot
@@ -123,7 +123,7 @@ section PartialOrder
 variable [PartialOrder α] [SuccOrder α] {a b : α} {C : α → Sort _}
 
 theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a := fun b hba =>
-  h b (Order.Covby.succ_eq hba)
+  h b (Covby.succ_eq hba)
 #align order.is_succ_limit_of_succ_ne Order.isSuccLimit_of_succ_ne
 
 theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a := by
@@ -277,9 +277,9 @@ section Preorder
 
 variable [Preorder α] {a : α}
 
-protected theorem IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h _ hab =>
+protected theorem _root_.IsMax.isPredLimit : IsMax a → IsPredLimit a := fun h _ hab =>
   not_isMax_of_lt hab.lt h
-#align is_max.is_pred_limit Order.IsMax.isPredLimit
+#align is_max.is_pred_limit IsMax.isPredLimit
 
 theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) :=
    IsMax.isPredLimit isMax_top

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

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

@@ -266,8 +266,10 @@ theorem isPredLimit_toDual_iff : IsPredLimit (toDual a) ↔ IsSuccLimit a := by
 #align order.is_pred_limit_to_dual_iff Order.isPredLimit_toDual_iff
 
 alias isSuccLimit_toDual_iff ↔ _ isPredLimit.dual
+#align order.is_pred_limit.dual Order.isPredLimit.dual
 
 alias isPredLimit_toDual_iff ↔ _ isSuccLimit.dual
+#align order.is_succ_limit.dual Order.isSuccLimit.dual
 
 end LT
 

@@ -288,7 +288,7 @@ variable [PredOrder α]
 protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a := by
   by_contra H
   exact h a (pred_covby_of_not_isMin H)
-#align order.isPredLimit.is_min Order.IsPredLimit.isMin
+#align order.is_pred_limit.is_min Order.IsPredLimit.isMin
 
 theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) := by
   contrapose! ha
@@ -356,7 +356,7 @@ theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b := fu
 
 theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b :=
   (isPredLimit.dual h).succ_lt
-#align order.isPredLimit.lt_pred Order.IsPredLimit.lt_pred
+#align order.is_pred_limit.lt_pred Order.IsPredLimit.lt_pred
 
 theorem IsPredLimit.lt_pred_iff (h : IsPredLimit a) : a < pred b ↔ a < b :=
   (isPredLimit.dual h).succ_lt_iff
@@ -401,7 +401,7 @@ variable [IsPredArchimedean α]
 
 protected theorem IsPredLimit.isMax (h : IsPredLimit a) : IsMax a :=
   (isPredLimit.dual h).isMin
-#align order.isPredLimit.is_max Order.IsPredLimit.isMax
+#align order.is_pred_limit.is_max Order.IsPredLimit.isMax
 
 @[simp]
 theorem isPredLimit_iff : IsPredLimit a ↔ IsMax a :=

I've avoided anything under Tactic or test.

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

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

@@ -128,7 +128,7 @@ theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a := fun
 
 theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a := by
   rw [not_isSuccLimit_iff_exists_covby]
-  refine' exists_congr fun b => ⟨fun hba => ⟨hba.lt.not_is_max, (Covby.succ_eq hba)⟩, _⟩
+  refine' exists_congr fun b => ⟨fun hba => ⟨hba.lt.not_isMax, (Covby.succ_eq hba)⟩, _⟩
   rintro ⟨h, rfl⟩
   exact covby_succ_of_not_isMax h
 #align order.not_is_succ_limit_iff Order.not_isSuccLimit_iff

Co-authored-by: Moritz Firsching <firsching@google.com> Co-authored-by: Arien Malec <arien.malec@gmail.com> Co-authored-by: Heather Macbeth <25316162+hrmacbeth@users.noreply.github.com>