File: Mathlib/Order/SuccPred/Basic.lean

full_name: SuccOrder.succ_le_of_lt
code: /-- Order equipped with a sensible successor function. -/
@[ext]
class SuccOrder (α : Type*) [Preorder α] where
  /-- Successor function-/
  succ : α → α
  /-- Proof of basic ordering with respect to `succ`-/
  le_succ : ∀ a, a ≤ succ a
  /-- Proof of interaction between `succ` and maximal element-/
  max_of_succ_le {a} : succ a ≤ a → IsMax a
  /-- Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
  succ_le_of_lt {a b} : a < b → succ a ≤ b
  /-- Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
  le_of_lt_succ {a b} : a < succ b → a ≤ b
goal: a < b → SuccOrder.succ a ≤ b

full_name: SuccOrder.le_of_lt_succ
code: /-- Order equipped with a sensible successor function. -/
@[ext]
class SuccOrder (α : Type*) [Preorder α] where
  /-- Successor function-/
  succ : α → α
  /-- Proof of basic ordering with respect to `succ`-/
  le_succ : ∀ a, a ≤ succ a
  /-- Proof of interaction between `succ` and maximal element-/
  max_of_succ_le {a} : succ a ≤ a → IsMax a
  /-- Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
  succ_le_of_lt {a b} : a < b → succ a ≤ b
  /-- Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
  le_of_lt_succ {a b} : a < succ b → a ≤ b
goal: a < SuccOrder.succ b → a ≤ b

full_name: SuccOrder
code: /-- Order equipped with a sensible successor function. -/
@[ext]
class SuccOrder (α : Type*) [Preorder α] where
  /-- Successor function-/
  succ : α → α
  /-- Proof of basic ordering with respect to `succ`-/
  le_succ : ∀ a, a ≤ succ a
  /-- Proof of interaction between `succ` and maximal element-/
  max_of_succ_le {a} : succ a ≤ a → IsMax a
  /-- Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
  succ_le_of_lt {a b} : a < b → succ a ≤ b
  /-- Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
  le_of_lt_succ {a b} : a < succ b → a ≤ b
goal: Type u_3

full_name: SuccOrder.le_succ
code: /-- Order equipped with a sensible successor function. -/
@[ext]
class SuccOrder (α : Type*) [Preorder α] where
  /-- Successor function-/
  succ : α → α
  /-- Proof of basic ordering with respect to `succ`-/
  le_succ : ∀ a, a ≤ succ a
  /-- Proof of interaction between `succ` and maximal element-/
  max_of_succ_le {a} : succ a ≤ a → IsMax a
  /-- Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
  succ_le_of_lt {a b} : a < b → succ a ≤ b
  /-- Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
  le_of_lt_succ {a b} : a < succ b → a ≤ b
goal: a ≤ SuccOrder.succ a

full_name: SuccOrder.max_of_succ_le
code: /-- Order equipped with a sensible successor function. -/
@[ext]
class SuccOrder (α : Type*) [Preorder α] where
  /-- Successor function-/
  succ : α → α
  /-- Proof of basic ordering with respect to `succ`-/
  le_succ : ∀ a, a ≤ succ a
  /-- Proof of interaction between `succ` and maximal element-/
  max_of_succ_le {a} : succ a ≤ a → IsMax a
  /-- Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
  succ_le_of_lt {a b} : a < b → succ a ≤ b
  /-- Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
  le_of_lt_succ {a b} : a < succ b → a ≤ b
goal: SuccOrder.succ a ≤ a → IsMax a

full_name: SuccOrder.succ
code: /-- Order equipped with a sensible successor function. -/
@[ext]
class SuccOrder (α : Type*) [Preorder α] where
  /-- Successor function-/
  succ : α → α
  /-- Proof of basic ordering with respect to `succ`-/
  le_succ : ∀ a, a ≤ succ a
  /-- Proof of interaction between `succ` and maximal element-/
  max_of_succ_le {a} : succ a ≤ a → IsMax a
  /-- Proof that `succ` satisfies ordering invariants between `LT` and `LE`-/
  succ_le_of_lt {a b} : a < b → succ a ≤ b
  /-- Proof that `succ` satisfies ordering invariants between `LE` and `LT`-/
  le_of_lt_succ {a b} : a < succ b → a ≤ b
goal: α → α

full_name: PredOrder.min_of_le_pred
code: /-- Order equipped with a sensible predecessor function. -/
@[ext]
class PredOrder (α : Type*) [Preorder α] where
  /-- Predecessor function-/
  pred : α → α
  /-- Proof of basic ordering with respect to `pred`-/
  pred_le : ∀ a, pred a ≤ a
  /-- Proof of interaction between `pred` and minimal element-/
  min_of_le_pred {a} : a ≤ pred a → IsMin a
  /-- Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
  le_pred_of_lt {a b} : a < b → a ≤ pred b
  /-- Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
  le_of_pred_lt {a b} : pred a < b → a ≤ b
goal: a ≤ PredOrder.pred a → IsMin a

full_name: PredOrder.pred
code: /-- Order equipped with a sensible predecessor function. -/
@[ext]
class PredOrder (α : Type*) [Preorder α] where
  /-- Predecessor function-/
  pred : α → α
  /-- Proof of basic ordering with respect to `pred`-/
  pred_le : ∀ a, pred a ≤ a
  /-- Proof of interaction between `pred` and minimal element-/
  min_of_le_pred {a} : a ≤ pred a → IsMin a
  /-- Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
  le_pred_of_lt {a b} : a < b → a ≤ pred b
  /-- Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
  le_of_pred_lt {a b} : pred a < b → a ≤ b
goal: α → α

full_name: PredOrder
code: /-- Order equipped with a sensible predecessor function. -/
@[ext]
class PredOrder (α : Type*) [Preorder α] where
  /-- Predecessor function-/
  pred : α → α
  /-- Proof of basic ordering with respect to `pred`-/
  pred_le : ∀ a, pred a ≤ a
  /-- Proof of interaction between `pred` and minimal element-/
  min_of_le_pred {a} : a ≤ pred a → IsMin a
  /-- Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
  le_pred_of_lt {a b} : a < b → a ≤ pred b
  /-- Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
  le_of_pred_lt {a b} : pred a < b → a ≤ b
goal: Type u_3

full_name: PredOrder.le_of_pred_lt
code: /-- Order equipped with a sensible predecessor function. -/
@[ext]
class PredOrder (α : Type*) [Preorder α] where
  /-- Predecessor function-/
  pred : α → α
  /-- Proof of basic ordering with respect to `pred`-/
  pred_le : ∀ a, pred a ≤ a
  /-- Proof of interaction between `pred` and minimal element-/
  min_of_le_pred {a} : a ≤ pred a → IsMin a
  /-- Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
  le_pred_of_lt {a b} : a < b → a ≤ pred b
  /-- Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
  le_of_pred_lt {a b} : pred a < b → a ≤ b
goal: PredOrder.pred a < b → a ≤ b

full_name: PredOrder.le_pred_of_lt
code: /-- Order equipped with a sensible predecessor function. -/
@[ext]
class PredOrder (α : Type*) [Preorder α] where
  /-- Predecessor function-/
  pred : α → α
  /-- Proof of basic ordering with respect to `pred`-/
  pred_le : ∀ a, pred a ≤ a
  /-- Proof of interaction between `pred` and minimal element-/
  min_of_le_pred {a} : a ≤ pred a → IsMin a
  /-- Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
  le_pred_of_lt {a b} : a < b → a ≤ pred b
  /-- Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
  le_of_pred_lt {a b} : pred a < b → a ≤ b
goal: a < b → a ≤ PredOrder.pred b

full_name: PredOrder.pred_le
code: /-- Order equipped with a sensible predecessor function. -/
@[ext]
class PredOrder (α : Type*) [Preorder α] where
  /-- Predecessor function-/
  pred : α → α
  /-- Proof of basic ordering with respect to `pred`-/
  pred_le : ∀ a, pred a ≤ a
  /-- Proof of interaction between `pred` and minimal element-/
  min_of_le_pred {a} : a ≤ pred a → IsMin a
  /-- Proof that `pred` satisfies ordering invariants between `LT` and `LE`-/
  le_pred_of_lt {a b} : a < b → a ≤ pred b
  /-- Proof that `pred` satisfies ordering invariants between `LE` and `LT`-/
  le_of_pred_lt {a b} : pred a < b → a ≤ b
goal: PredOrder.pred a ≤ a

full_name: instPredOrderOrderDualOfSuccOrder
code: instance [Preorder α] [SuccOrder α] :
    PredOrder αᵒᵈ 
goal: PredOrder αᵒᵈ

full_name: instSuccOrderOrderDualOfPredOrder
code: instance [Preorder α] [PredOrder α] :
    SuccOrder αᵒᵈ 
goal: SuccOrder αᵒᵈ

full_name: SuccOrder.ofSuccLeIffOfLeLtSucc
code: /-- A constructor for `SuccOrder α` usable when `α` has no maximal element. -/
def SuccOrder.ofSuccLeIffOfLeLtSucc (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b)
    (hle_of_lt_succ : ∀ {a b}, a < succ b → a ≤ b) : SuccOrder α 
goal: SuccOrder α

full_name: PredOrder.ofLePredIffOfPredLePred
code: /-- A constructor for `PredOrder α` usable when `α` has no minimal element. -/
def PredOrder.ofLePredIffOfPredLePred (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b)
    (hle_of_pred_lt : ∀ {a b}, pred a < b → a ≤ b) : PredOrder α 
goal: PredOrder α

full_name: SuccOrder.ofCore_succ
code: /-- A constructor for `SuccOrder α` for `α` a linear order. -/
@[simps]
def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a < b ↔ succ a ≤ b)
    (hm : ∀ a, IsMax a → succ a = a) : SuccOrder α 
goal: ∀ (a : α), SuccOrder.succ a = succ a

full_name: SuccOrder.ofCore
code: /-- A constructor for `SuccOrder α` for `α` a linear order. -/
@[simps]
def SuccOrder.ofCore (succ : α → α) (hn : ∀ {a}, ¬IsMax a → ∀ b, a < b ↔ succ a ≤ b)
    (hm : ∀ a, IsMax a → succ a = a) : SuccOrder α 
goal: SuccOrder α

full_name: PredOrder.ofCore_pred
code: /-- A constructor for `PredOrder α` for `α` a linear order. -/
@[simps]
def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
    (hn : ∀ {a}, ¬IsMin a → ∀ b, b ≤ pred a ↔ b < a) (hm : ∀ a, IsMin a → pred a = a) :
    PredOrder α 
goal: ∀ (a : α), PredOrder.pred a = pred a

full_name: PredOrder.ofCore
code: /-- A constructor for `PredOrder α` for `α` a linear order. -/
@[simps]
def PredOrder.ofCore {α} [LinearOrder α] (pred : α → α)
    (hn : ∀ {a}, ¬IsMin a → ∀ b, b ≤ pred a ↔ b < a) (hm : ∀ a, IsMin a → pred a = a) :
    PredOrder α 
goal: PredOrder α

full_name: SuccOrder.ofSuccLeIff
code: /-- A constructor for `SuccOrder α` usable when `α` is a linear order with no maximal element. -/
def SuccOrder.ofSuccLeIff (succ : α → α) (hsucc_le_iff : ∀ {a b}, succ a ≤ b ↔ a < b) :
    SuccOrder α 
goal: SuccOrder α

full_name: PredOrder.ofLePredIff
code: /-- A constructor for `PredOrder α` usable when `α` is a linear order with no minimal element. -/
def PredOrder.ofLePredIff (pred : α → α) (hle_pred_iff : ∀ {a b}, a ≤ pred b ↔ a < b) :
    PredOrder α 
goal: PredOrder α

full_name: SuccOrder.ofLinearWellFoundedLT
code: /-- A well-order is a `SuccOrder`. -/
noncomputable def SuccOrder.ofLinearWellFoundedLT [WellFoundedLT α] : SuccOrder α 
goal: SuccOrder α

full_name: PredOrder.ofLinearWellFoundedGT
code: /-- A linear order with well-founded greater-than relation is a `PredOrder`. -/
noncomputable def PredOrder.ofLinearWellFoundedGT (α) [LinearOrder α] [WellFoundedGT α] :
    PredOrder α 
goal: PredOrder α

full_name: Order.succ
code: /-- The successor of an element. If `a` is not maximal, then `succ a` is the least element greater
than `a`. If `a` is maximal, then `succ a = a`. -/
def succ : α → α 
goal: α → α

full_name: Order.le_succ
code: theorem le_succ : ∀ a : α, a ≤ succ a 
goal: a ≤ Order.succ a

full_name: Order.max_of_succ_le
code: theorem max_of_succ_le {a : α} : succ a ≤ a → IsMax a 
goal: Order.succ a ≤ a → IsMax a

full_name: Order.succ_le_of_lt
code: theorem succ_le_of_lt {a b : α} : a < b → succ a ≤ b 
goal: a < b → Order.succ a ≤ b

full_name: Order.le_of_lt_succ
code: theorem le_of_lt_succ {a b : α} : a < succ b → a ≤ b 
goal: a < Order.succ b → a ≤ b

full_name: Order.succ_le_iff_isMax
code: @[simp]
theorem succ_le_iff_isMax : succ a ≤ a ↔ IsMax a 
goal: Order.succ a ≤ a ↔ IsMax a

full_name: Order.lt_succ_iff_not_isMax
code: @[simp]
theorem lt_succ_iff_not_isMax : a < succ a ↔ ¬IsMax a 
goal: a < Order.succ a ↔ ¬IsMax a

full_name: Order.wcovBy_succ
code: theorem wcovBy_succ (a : α) : a ⩿ succ a 
goal: a ⩿ Order.succ a

full_name: Order.covBy_succ_of_not_isMax
code: theorem covBy_succ_of_not_isMax (h : ¬IsMax a) : a ⋖ succ a 
goal: a ⋖ Order.succ a

full_name: Order.lt_succ_iff_of_not_isMax
code: theorem lt_succ_iff_of_not_isMax (ha : ¬IsMax a) : b < succ a ↔ b ≤ a 
goal: b < Order.succ a ↔ b ≤ a

full_name: Order.succ_le_iff_of_not_isMax
code: theorem succ_le_iff_of_not_isMax (ha : ¬IsMax a) : succ a ≤ b ↔ a < b 
goal: Order.succ a ≤ b ↔ a < b

full_name: Order.succ_lt_succ_of_not_isMax
code: lemma succ_lt_succ_of_not_isMax (h : a < b) (hb : ¬ IsMax b) : succ a < succ b 
goal: Order.succ a < Order.succ b

full_name: Order.succ_lt_succ_iff_of_not_isMax
code: theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
    succ a < succ b ↔ a < b 
goal: Order.succ a < Order.succ b ↔ a < b

full_name: Order.succ_le_succ_iff_of_not_isMax
code: theorem succ_le_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
    succ a ≤ succ b ↔ a ≤ b 
goal: Order.succ a ≤ Order.succ b ↔ a ≤ b

full_name: Order.succ_le_succ
code: @[simp, mono]
theorem succ_le_succ (h : a ≤ b) : succ a ≤ succ b 
goal: Order.succ a ≤ Order.succ b

full_name: Order.succ_mono
code: theorem succ_mono : Monotone (succ : α → α) 
goal: Monotone Order.succ

full_name: Order.le_succ_of_wcovBy
code: /-- See also `Order.succ_eq_of_covBy`. -/
lemma le_succ_of_wcovBy (h : a ⩿ b) : b ≤ succ a 
goal: b ≤ Order.succ a

full_name: Order.le_succ_iterate
code: theorem le_succ_iterate (k : ℕ) (x : α) : x ≤ succ^[k] x 
goal: x ≤ Order.succ^[k] x

full_name: Order.isMax_iterate_succ_of_eq_of_lt
code: theorem isMax_iterate_succ_of_eq_of_lt {n m : ℕ} (h_eq : succ^[n] a = succ^[m] a)
    (h_lt : n < m) : IsMax (succ^[n] a) 
goal: IsMax (Order.succ^[n] a)

full_name: Order.isMax_iterate_succ_of_eq_of_ne
code: theorem isMax_iterate_succ_of_eq_of_ne {n m : ℕ} (h_eq : succ^[n] a = succ^[m] a)
    (h_ne : n ≠ m) : IsMax (succ^[n] a) 
goal: IsMax (Order.succ^[n] a)

full_name: Order.Iio_succ_of_not_isMax
code: theorem Iio_succ_of_not_isMax (ha : ¬IsMax a) : Iio (succ a) = Iic a 
goal: Set.Iio (Order.succ a) = Set.Iic a

full_name: Order.Ici_succ_of_not_isMax
code: theorem Ici_succ_of_not_isMax (ha : ¬IsMax a) : Ici (succ a) = Ioi a 
goal: Set.Ici (Order.succ a) = Set.Ioi a

full_name: Order.Ico_succ_right_of_not_isMax
code: theorem Ico_succ_right_of_not_isMax (hb : ¬IsMax b) : Ico a (succ b) = Icc a b 
goal: Set.Ico a (Order.succ b) = Set.Icc a b

full_name: Order.Ioo_succ_right_of_not_isMax
code: theorem Ioo_succ_right_of_not_isMax (hb : ¬IsMax b) : Ioo a (succ b) = Ioc a b 
goal: Set.Ioo a (Order.succ b) = Set.Ioc a b

full_name: Order.Icc_succ_left_of_not_isMax
code: theorem Icc_succ_left_of_not_isMax (ha : ¬IsMax a) : Icc (succ a) b = Ioc a b 
goal: Set.Icc (Order.succ a) b = Set.Ioc a b

full_name: Order.Ico_succ_left_of_not_isMax
code: theorem Ico_succ_left_of_not_isMax (ha : ¬IsMax a) : Ico (succ a) b = Ioo a b 
goal: Set.Ico (Order.succ a) b = Set.Ioo a b

full_name: Order.lt_succ
code: theorem lt_succ (a : α) : a < succ a 
goal: a < Order.succ a

full_name: Order.lt_succ_iff
code: @[simp]
theorem lt_succ_iff : a < succ b ↔ a ≤ b 
goal: a < Order.succ b ↔ a ≤ b

full_name: Order.succ_le_iff
code: @[simp]
theorem succ_le_iff : succ a ≤ b ↔ a < b 
goal: Order.succ a ≤ b ↔ a < b

full_name: Order.succ_le_succ_iff
code: theorem succ_le_succ_iff : succ a ≤ succ b ↔ a ≤ b 
goal: Order.succ a ≤ Order.succ b ↔ a ≤ b

full_name: Order.succ_lt_succ_iff
code: theorem succ_lt_succ_iff : succ a < succ b ↔ a < b 
goal: Order.succ a < Order.succ b ↔ a < b

full_name: Order.succ_strictMono
code: theorem succ_strictMono : StrictMono (succ : α → α) 
goal: StrictMono Order.succ

full_name: Order.covBy_succ
code: theorem covBy_succ (a : α) : a ⋖ succ a 
goal: a ⋖ Order.succ a

full_name: Order.Iio_succ
code: @[simp]
theorem Iio_succ (a : α) : Iio (succ a) = Iic a 
goal: Set.Iio (Order.succ a) = Set.Iic a

full_name: Order.Ici_succ
code: @[simp]
theorem Ici_succ (a : α) : Ici (succ a) = Ioi a 
goal: Set.Ici (Order.succ a) = Set.Ioi a

full_name: Order.Ico_succ_right
code: @[simp]
theorem Ico_succ_right (a b : α) : Ico a (succ b) = Icc a b 
goal: Set.Ico a (Order.succ b) = Set.Icc a b

full_name: Order.Ioo_succ_right
code: @[simp]
theorem Ioo_succ_right (a b : α) : Ioo a (succ b) = Ioc a b 
goal: Set.Ioo a (Order.succ b) = Set.Ioc a b

full_name: Order.Icc_succ_left
code: @[simp]
theorem Icc_succ_left (a b : α) : Icc (succ a) b = Ioc a b 
goal: Set.Icc (Order.succ a) b = Set.Ioc a b

full_name: Order.Ico_succ_left
code: @[simp]
theorem Ico_succ_left (a b : α) : Ico (succ a) b = Ioo a b 
goal: Set.Ico (Order.succ a) b = Set.Ioo a b

full_name: Order.succ_eq_iff_isMax
code: @[simp]
theorem succ_eq_iff_isMax : succ a = a ↔ IsMax a 
goal: Order.succ a = a ↔ IsMax a

full_name: Order.succ_eq_succ_iff_of_not_isMax
code: theorem succ_eq_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
    succ a = succ b ↔ a = b 
goal: Order.succ a = Order.succ b ↔ a = b

full_name: Order.le_le_succ_iff
code: theorem le_le_succ_iff : a ≤ b ∧ b ≤ succ a ↔ b = a ∨ b = succ a 
goal: a ≤ b ∧ b ≤ Order.succ a ↔ b = a ∨ b = Order.succ a

full_name: Order.succ_eq_of_covBy
code: /-- See also `Order.le_succ_of_wcovBy`. -/
lemma succ_eq_of_covBy (h : a ⋖ b) : succ a = b 
goal: Order.succ a = b

full_name: Order.le_succ_iff_eq_or_le
code: theorem le_succ_iff_eq_or_le : a ≤ succ b ↔ a = succ b ∨ a ≤ b 
goal: a ≤ Order.succ b ↔ a = Order.succ b ∨ a ≤ b

full_name: Order.lt_succ_iff_eq_or_lt_of_not_isMax
code: theorem lt_succ_iff_eq_or_lt_of_not_isMax (hb : ¬IsMax b) : a < succ b ↔ a = b ∨ a < b 
goal: a < Order.succ b ↔ a = b ∨ a < b

full_name: Order.Iic_succ
code: theorem Iic_succ (a : α) : Iic (succ a) = insert (succ a) (Iic a) 
goal: Set.Iic (Order.succ a) = insert (Order.succ a) (Set.Iic a)

full_name: Order.Icc_succ_right
code: theorem Icc_succ_right (h : a ≤ succ b) : Icc a (succ b) = insert (succ b) (Icc a b) 
goal: Set.Icc a (Order.succ b) = insert (Order.succ b) (Set.Icc a b)

full_name: Order.Ioc_succ_right
code: theorem Ioc_succ_right (h : a < succ b) : Ioc a (succ b) = insert (succ b) (Ioc a b) 
goal: Set.Ioc a (Order.succ b) = insert (Order.succ b) (Set.Ioc a b)

full_name: Order.Iio_succ_eq_insert_of_not_isMax
code: theorem Iio_succ_eq_insert_of_not_isMax (h : ¬IsMax a) : Iio (succ a) = insert a (Iio a) 
goal: Set.Iio (Order.succ a) = insert a (Set.Iio a)

full_name: Order.Ico_succ_right_eq_insert_of_not_isMax
code: theorem Ico_succ_right_eq_insert_of_not_isMax (h₁ : a ≤ b) (h₂ : ¬IsMax b) :
    Ico a (succ b) = insert b (Ico a b) 
goal: Set.Ico a (Order.succ b) = insert b (Set.Ico a b)

full_name: Order.Ioo_succ_right_eq_insert_of_not_isMax
code: theorem Ioo_succ_right_eq_insert_of_not_isMax (h₁ : a < b) (h₂ : ¬IsMax b) :
    Ioo a (succ b) = insert b (Ioo a b) 
goal: Set.Ioo a (Order.succ b) = insert b (Set.Ioo a b)

full_name: Order.succ_eq_succ_iff
code: @[simp]
theorem succ_eq_succ_iff : succ a = succ b ↔ a = b 
goal: Order.succ a = Order.succ b ↔ a = b

full_name: Order.succ_injective
code: theorem succ_injective : Injective (succ : α → α) 
goal: Function.Injective Order.succ

full_name: Order.succ_ne_succ_iff
code: theorem succ_ne_succ_iff : succ a ≠ succ b ↔ a ≠ b 
goal: Order.succ a ≠ Order.succ b ↔ a ≠ b

full_name: Order.lt_succ_iff_eq_or_lt
code: theorem lt_succ_iff_eq_or_lt : a < succ b ↔ a = b ∨ a < b 
goal: a < Order.succ b ↔ a = b ∨ a < b

full_name: Order.succ_eq_iff_covBy
code: theorem succ_eq_iff_covBy : succ a = b ↔ a ⋖ b 
goal: Order.succ a = b ↔ a ⋖ b

full_name: Order.Iio_succ_eq_insert
code: theorem Iio_succ_eq_insert (a : α) : Iio (succ a) = insert a (Iio a) 
goal: Set.Iio (Order.succ a) = insert a (Set.Iio a)

full_name: Order.Ico_succ_right_eq_insert
code: theorem Ico_succ_right_eq_insert (h : a ≤ b) : Ico a (succ b) = insert b (Ico a b) 
goal: Set.Ico a (Order.succ b) = insert b (Set.Ico a b)

full_name: Order.Ioo_succ_right_eq_insert
code: theorem Ioo_succ_right_eq_insert (h : a < b) : Ioo a (succ b) = insert b (Ioo a b) 
goal: Set.Ioo a (Order.succ b) = insert b (Set.Ioo a b)

full_name: Order.succ_top
code: @[simp]
theorem succ_top : succ (⊤ : α) = ⊤ 
goal: Order.succ ⊤ = ⊤

full_name: Order.succ_le_iff_eq_top
code: theorem succ_le_iff_eq_top : succ a ≤ a ↔ a = ⊤ 
goal: Order.succ a ≤ a ↔ a = ⊤

full_name: Order.lt_succ_iff_ne_top
code: theorem lt_succ_iff_ne_top : a < succ a ↔ a ≠ ⊤ 
goal: a < Order.succ a ↔ a ≠ ⊤

full_name: Order.lt_succ_bot_iff
code: theorem lt_succ_bot_iff [NoMaxOrder α] : a < succ ⊥ ↔ a = ⊥ 
goal: a < Order.succ ⊥ ↔ a = ⊥

full_name: Order.le_succ_bot_iff
code: theorem le_succ_bot_iff : a ≤ succ ⊥ ↔ a = ⊥ ∨ a = succ ⊥ 
goal: a ≤ Order.succ ⊥ ↔ a = ⊥ ∨ a = Order.succ ⊥

full_name: Order.bot_lt_succ
code: theorem bot_lt_succ (a : α) : ⊥ < succ a 
goal: ⊥ < Order.succ a

full_name: Order.succ_ne_bot
code: theorem succ_ne_bot (a : α) : succ a ≠ ⊥ 
goal: Order.succ a ≠ ⊥

full_name: Order.instSubsingletonSuccOrder
code: /-- There is at most one way to define the successors in a `PartialOrder`. -/
instance [PartialOrder α] : Subsingleton (SuccOrder α) 
goal: Subsingleton (SuccOrder α)

full_name: Order.succ_eq_iInf
code: theorem succ_eq_iInf (a : α) : succ a = ⨅ (b) (_ : a < b), b 
goal: Order.succ a = ⨅ b, ⨅ (_ : a < b), b

full_name: Order.pred
code: /-- The predecessor of an element. If `a` is not minimal, then `pred a` is the greatest element less
than `a`. If `a` is minimal, then `pred a = a`. -/
def pred : α → α 
goal: α → α

full_name: Order.pred_le
code: theorem pred_le : ∀ a : α, pred a ≤ a 
goal: Order.pred a ≤ a

full_name: Order.min_of_le_pred
code: theorem min_of_le_pred {a : α} : a ≤ pred a → IsMin a 
goal: a ≤ Order.pred a → IsMin a

full_name: Order.le_pred_of_lt
code: theorem le_pred_of_lt {a b : α} : a < b → a ≤ pred b 
goal: a < b → a ≤ Order.pred b

full_name: Order.le_of_pred_lt
code: theorem le_of_pred_lt {a b : α} : pred a < b → a ≤ b 
goal: Order.pred a < b → a ≤ b

full_name: Order.le_pred_iff_isMin
code: @[simp]
theorem le_pred_iff_isMin : a ≤ pred a ↔ IsMin a 
goal: a ≤ Order.pred a ↔ IsMin a

full_name: Order.pred_lt_iff_not_isMin
code: @[simp]
theorem pred_lt_iff_not_isMin : pred a < a ↔ ¬IsMin a 
goal: Order.pred a < a ↔ ¬IsMin a

full_name: Order.pred_wcovBy
code: theorem pred_wcovBy (a : α) : pred a ⩿ a 
goal: Order.pred a ⩿ a

full_name: Order.pred_covBy_of_not_isMin
code: theorem pred_covBy_of_not_isMin (h : ¬IsMin a) : pred a ⋖ a 
goal: Order.pred a ⋖ a

full_name: Order.pred_lt_iff_of_not_isMin
code: theorem pred_lt_iff_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a ≤ b 
goal: Order.pred a < b ↔ a ≤ b

full_name: Order.le_pred_iff_of_not_isMin
code: theorem le_pred_iff_of_not_isMin (ha : ¬IsMin a) : b ≤ pred a ↔ b < a 
goal: b ≤ Order.pred a ↔ b < a

full_name: Order.pred_lt_pred_of_not_isMin
code: lemma pred_lt_pred_of_not_isMin (h : a < b) (ha : ¬ IsMin a) : pred a < pred b 
goal: Order.pred a < Order.pred b

full_name: Order.pred_lt_pred_iff_of_not_isMin
code: theorem pred_lt_pred_iff_of_not_isMin (ha : ¬IsMin a) (hb : ¬IsMin b) :
    pred a < pred b ↔ a < b 
goal: Order.pred a < Order.pred b ↔ a < b

full_name: Order.pred_le_pred_iff_of_not_isMin
code: theorem pred_le_pred_iff_of_not_isMin (ha : ¬IsMin a) (hb : ¬IsMin b) :
    pred a ≤ pred b ↔ a ≤ b 
goal: Order.pred a ≤ Order.pred b ↔ a ≤ b

full_name: Order.pred_le_pred
code: @[simp, mono]
theorem pred_le_pred {a b : α} (h : a ≤ b) : pred a ≤ pred b 
goal: Order.pred a ≤ Order.pred b

full_name: Order.pred_mono
code: theorem pred_mono : Monotone (pred : α → α) 
goal: Monotone Order.pred

full_name: Order.pred_le_of_wcovBy
code: /-- See also `Order.pred_eq_of_covBy`. -/
lemma pred_le_of_wcovBy (h : a ⩿ b) : pred b ≤ a 
goal: Order.pred b ≤ a

full_name: Order.pred_iterate_le
code: theorem pred_iterate_le (k : ℕ) (x : α) : pred^[k] x ≤ x 
goal: Order.pred^[k] x ≤ x

full_name: Order.isMin_iterate_pred_of_eq_of_lt
code: theorem isMin_iterate_pred_of_eq_of_lt {n m : ℕ} (h_eq : pred^[n] a = pred^[m] a)
    (h_lt : n < m) : IsMin (pred^[n] a) 
goal: IsMin (Order.pred^[n] a)

full_name: Order.isMin_iterate_pred_of_eq_of_ne
code: theorem isMin_iterate_pred_of_eq_of_ne {n m : ℕ} (h_eq : pred^[n] a = pred^[m] a)
    (h_ne : n ≠ m) : IsMin (pred^[n] a) 
goal: IsMin (Order.pred^[n] a)

full_name: Order.Ioi_pred_of_not_isMin
code: theorem Ioi_pred_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = Ici a 
goal: Set.Ioi (Order.pred a) = Set.Ici a

full_name: Order.Iic_pred_of_not_isMin
code: theorem Iic_pred_of_not_isMin (ha : ¬IsMin a) : Iic (pred a) = Iio a 
goal: Set.Iic (Order.pred a) = Set.Iio a

full_name: Order.Ioc_pred_left_of_not_isMin
code: theorem Ioc_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioc (pred a) b = Icc a b 
goal: Set.Ioc (Order.pred a) b = Set.Icc a b

full_name: Order.Ioo_pred_left_of_not_isMin
code: theorem Ioo_pred_left_of_not_isMin (ha : ¬IsMin a) : Ioo (pred a) b = Ico a b 
goal: Set.Ioo (Order.pred a) b = Set.Ico a b

full_name: Order.Icc_pred_right_of_not_isMin
code: theorem Icc_pred_right_of_not_isMin (ha : ¬IsMin b) : Icc a (pred b) = Ico a b 
goal: Set.Icc a (Order.pred b) = Set.Ico a b

full_name: Order.Ioc_pred_right_of_not_isMin
code: theorem Ioc_pred_right_of_not_isMin (ha : ¬IsMin b) : Ioc a (pred b) = Ioo a b 
goal: Set.Ioc a (Order.pred b) = Set.Ioo a b

full_name: Order.pred_lt
code: theorem pred_lt (a : α) : pred a < a 
goal: Order.pred a < a

full_name: Order.pred_lt_iff
code: @[simp]
theorem pred_lt_iff : pred a < b ↔ a ≤ b 
goal: Order.pred a < b ↔ a ≤ b

full_name: Order.le_pred_iff
code: @[simp]
theorem le_pred_iff : a ≤ pred b ↔ a < b 
goal: a ≤ Order.pred b ↔ a < b

full_name: Order.pred_le_pred_iff
code: theorem pred_le_pred_iff : pred a ≤ pred b ↔ a ≤ b 
goal: Order.pred a ≤ Order.pred b ↔ a ≤ b

full_name: Order.pred_lt_pred_iff
code: theorem pred_lt_pred_iff : pred a < pred b ↔ a < b 
goal: Order.pred a < Order.pred b ↔ a < b

full_name: Order.pred_strictMono
code: theorem pred_strictMono : StrictMono (pred : α → α) 
goal: StrictMono Order.pred

full_name: Order.pred_covBy
code: theorem pred_covBy (a : α) : pred a ⋖ a 
goal: Order.pred a ⋖ a

full_name: Order.Ioi_pred
code: @[simp]
theorem Ioi_pred (a : α) : Ioi (pred a) = Ici a 
goal: Set.Ioi (Order.pred a) = Set.Ici a

full_name: Order.Iic_pred
code: @[simp]
theorem Iic_pred (a : α) : Iic (pred a) = Iio a 
goal: Set.Iic (Order.pred a) = Set.Iio a

full_name: Order.Ioc_pred_left
code: @[simp]
theorem Ioc_pred_left (a b : α) : Ioc (pred a) b = Icc a b 
goal: Set.Ioc (Order.pred a) b = Set.Icc a b

full_name: Order.Ioo_pred_left
code: @[simp]
theorem Ioo_pred_left (a b : α) : Ioo (pred a) b = Ico a b 
goal: Set.Ioo (Order.pred a) b = Set.Ico a b

full_name: Order.Icc_pred_right
code: @[simp]
theorem Icc_pred_right (a b : α) : Icc a (pred b) = Ico a b 
goal: Set.Icc a (Order.pred b) = Set.Ico a b

full_name: Order.Ioc_pred_right
code: @[simp]
theorem Ioc_pred_right (a b : α) : Ioc a (pred b) = Ioo a b 
goal: Set.Ioc a (Order.pred b) = Set.Ioo a b

full_name: Order.pred_eq_iff_isMin
code: @[simp]
theorem pred_eq_iff_isMin : pred a = a ↔ IsMin a 
goal: Order.pred a = a ↔ IsMin a

full_name: Order.pred_eq_pred_iff_of_not_isMin
code: theorem pred_eq_pred_iff_of_not_isMin (ha : ¬IsMin a) (hb : ¬IsMin b) :
    pred a = pred b ↔ a = b 
goal: Order.pred a = Order.pred b ↔ a = b

full_name: Order.pred_le_le_iff
code: theorem pred_le_le_iff {a b : α} : pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = pred a 
goal: Order.pred a ≤ b ∧ b ≤ a ↔ b = a ∨ b = Order.pred a

full_name: Order.pred_eq_of_covBy
code: /-- See also `Order.pred_le_of_wcovBy`. -/
lemma pred_eq_of_covBy (h : a ⋖ b) : pred b = a 
goal: Order.pred b = a

full_name: Order.pred_le_iff_eq_or_le
code: theorem pred_le_iff_eq_or_le : pred a ≤ b ↔ b = pred a ∨ a ≤ b 
goal: Order.pred a ≤ b ↔ b = Order.pred a ∨ a ≤ b

full_name: Order.pred_lt_iff_eq_or_lt_of_not_isMin
code: theorem pred_lt_iff_eq_or_lt_of_not_isMin (ha : ¬IsMin a) : pred a < b ↔ a = b ∨ a < b 
goal: Order.pred a < b ↔ a = b ∨ a < b

full_name: Order.Ici_pred
code: theorem Ici_pred (a : α) : Ici (pred a) = insert (pred a) (Ici a) 
goal: Set.Ici (Order.pred a) = insert (Order.pred a) (Set.Ici a)

full_name: Order.Ioi_pred_eq_insert_of_not_isMin
code: theorem Ioi_pred_eq_insert_of_not_isMin (ha : ¬IsMin a) : Ioi (pred a) = insert a (Ioi a) 
goal: Set.Ioi (Order.pred a) = insert a (Set.Ioi a)

full_name: Order.Icc_pred_left
code: theorem Icc_pred_left (h : pred a ≤ b) : Icc (pred a) b = insert (pred a) (Icc a b) 
goal: Set.Icc (Order.pred a) b = insert (Order.pred a) (Set.Icc a b)

full_name: Order.Ico_pred_left
code: theorem Ico_pred_left (h : pred a < b) : Ico (pred a) b = insert (pred a) (Ico a b) 
goal: Set.Ico (Order.pred a) b = insert (Order.pred a) (Set.Ico a b)

full_name: Order.pred_eq_pred_iff
code: @[simp]
theorem pred_eq_pred_iff : pred a = pred b ↔ a = b 
goal: Order.pred a = Order.pred b ↔ a = b

full_name: Order.pred_injective
code: theorem pred_injective : Injective (pred : α → α) 
goal: Function.Injective Order.pred

full_name: Order.pred_ne_pred_iff
code: theorem pred_ne_pred_iff : pred a ≠ pred b ↔ a ≠ b 
goal: Order.pred a ≠ Order.pred b ↔ a ≠ b

full_name: Order.pred_lt_iff_eq_or_lt
code: theorem pred_lt_iff_eq_or_lt : pred a < b ↔ a = b ∨ a < b 
goal: Order.pred a < b ↔ a = b ∨ a < b

full_name: Order.pred_eq_iff_covBy
code: theorem pred_eq_iff_covBy : pred b = a ↔ a ⋖ b 
goal: Order.pred b = a ↔ a ⋖ b

full_name: Order.Ioi_pred_eq_insert
code: theorem Ioi_pred_eq_insert (a : α) : Ioi (pred a) = insert a (Ioi a) 
goal: Set.Ioi (Order.pred a) = insert a (Set.Ioi a)

full_name: Order.Ico_pred_right_eq_insert
code: theorem Ico_pred_right_eq_insert (h : a ≤ b) : Ioc (pred a) b = insert a (Ioc a b) 
goal: Set.Ioc (Order.pred a) b = insert a (Set.Ioc a b)

full_name: Order.Ioo_pred_right_eq_insert
code: theorem Ioo_pred_right_eq_insert (h : a < b) : Ioo (pred a) b = insert a (Ioo a b) 
goal: Set.Ioo (Order.pred a) b = insert a (Set.Ioo a b)

full_name: Order.pred_bot
code: @[simp]
theorem pred_bot : pred (⊥ : α) = ⊥ 
goal: Order.pred ⊥ = ⊥

full_name: Order.le_pred_iff_eq_bot
code: theorem le_pred_iff_eq_bot : a ≤ pred a ↔ a = ⊥ 
goal: a ≤ Order.pred a ↔ a = ⊥

full_name: Order.pred_lt_iff_ne_bot
code: theorem pred_lt_iff_ne_bot : pred a < a ↔ a ≠ ⊥ 
goal: Order.pred a < a ↔ a ≠ ⊥

full_name: Order.pred_top_lt_iff
code: theorem pred_top_lt_iff [NoMinOrder α] : pred ⊤ < a ↔ a = ⊤ 
goal: Order.pred ⊤ < a ↔ a = ⊤

full_name: Order.pred_top_le_iff
code: theorem pred_top_le_iff : pred ⊤ ≤ a ↔ a = ⊤ ∨ a = pred ⊤ 
goal: Order.pred ⊤ ≤ a ↔ a = ⊤ ∨ a = Order.pred ⊤

full_name: Order.pred_lt_top
code: theorem pred_lt_top (a : α) : pred a < ⊤ 
goal: Order.pred a < ⊤

full_name: Order.pred_ne_top
code: theorem pred_ne_top (a : α) : pred a ≠ ⊤ 
goal: Order.pred a ≠ ⊤

full_name: Order.instSubsingletonPredOrder
code: /-- There is at most one way to define the predecessors in a `PartialOrder`. -/
instance [PartialOrder α] : Subsingleton (PredOrder α) 
goal: Subsingleton (PredOrder α)

full_name: Order.pred_eq_iSup
code: theorem pred_eq_iSup (a : α) : pred a = ⨆ (b) (_ : b < a), b 
goal: Order.pred a = ⨆ b, ⨆ (_ : b < a), b

full_name: Order.le_succ_pred
code: lemma le_succ_pred (a : α) : a ≤ succ (pred a) 
goal: a ≤ Order.succ (Order.pred a)

full_name: Order.pred_succ_le
code: lemma pred_succ_le (a : α) : pred (succ a) ≤ a 
goal: Order.pred (Order.succ a) ≤ a

full_name: Order.pred_le_iff_le_succ
code: lemma pred_le_iff_le_succ : pred a ≤ b ↔ a ≤ succ b 
goal: Order.pred a ≤ b ↔ a ≤ Order.succ b

full_name: Order.gc_pred_succ
code: lemma gc_pred_succ : GaloisConnection (pred : α → α) succ 
goal: GaloisConnection Order.pred Order.succ

full_name: Order.succ_pred_of_not_isMin
code: @[simp]
theorem succ_pred_of_not_isMin (h : ¬IsMin a) : succ (pred a) = a 
goal: Order.succ (Order.pred a) = a

full_name: Order.pred_succ_of_not_isMax
code: @[simp]
theorem pred_succ_of_not_isMax (h : ¬IsMax a) : pred (succ a) = a 
goal: Order.pred (Order.succ a) = a

full_name: Order.succ_pred
code: theorem succ_pred [NoMinOrder α] (a : α) : succ (pred a) = a 
goal: Order.succ (Order.pred a) = a

full_name: Order.pred_succ
code: theorem pred_succ [NoMaxOrder α] (a : α) : pred (succ a) = a 
goal: Order.pred (Order.succ a) = a

full_name: Order.pred_succ_iterate_of_not_isMax
code: theorem pred_succ_iterate_of_not_isMax (i : α) (n : ℕ) (hin : ¬IsMax (succ^[n - 1] i)) :
    pred^[n] (succ^[n] i) = i 
goal: Order.pred^[n] (Order.succ^[n] i) = i

full_name: Order.succ_pred_iterate_of_not_isMin
code: theorem succ_pred_iterate_of_not_isMin (i : α) (n : ℕ) (hin : ¬IsMin (pred^[n - 1] i)) :
    succ^[n] (pred^[n] i) = i 
goal: Order.succ^[n] (Order.pred^[n] i) = i

full_name: WithTop.instSuccOrder
code: instance : SuccOrder (WithTop α) 
goal: SuccOrder (WithTop α)

full_name: WithTop.succ_coe_top
code: @[simp]
theorem succ_coe_top : succ ↑(⊤ : α) = (⊤ : WithTop α) 
goal: Order.succ ↑⊤ = ⊤

full_name: WithTop.succ_coe_of_ne_top
code: theorem succ_coe_of_ne_top {a : α} (h : a ≠ ⊤) : succ (↑a : WithTop α) = ↑(succ a) 
goal: Order.succ ↑a = ↑(Order.succ a)

full_name: WithTop.instPredOrder
code: instance : PredOrder (WithTop α) 
goal: PredOrder (WithTop α)

full_name: WithTop.pred_top
code: @[simp]
theorem pred_top : pred (⊤ : WithTop α) = ↑(⊤ : α) 
goal: Order.pred ⊤ = ↑⊤

full_name: WithTop.pred_coe
code: @[simp]
theorem pred_coe (a : α) : pred (↑a : WithTop α) = ↑(pred a) 
goal: Order.pred ↑a = ↑(Order.pred a)

full_name: WithTop.pred_untop
code: @[simp]
theorem pred_untop :
    ∀ (a : WithTop α) (ha : a ≠ ⊤),
      pred (a.untop ha) = (pred a).untop (by induction a <;> simp)
  
goal: Order.pred (a.untop ha) = (Order.pred a).untop ⋯

full_name: WithTop.succOrderOfNoMaxOrder
code: instance succOrderOfNoMaxOrder : SuccOrder (WithTop α) 
goal: SuccOrder (WithTop α)

full_name: WithTop.succ_coe
code: @[simp]
theorem succ_coe (a : α) : succ (↑a : WithTop α) = ↑(succ a) 
goal: Order.succ ↑a = ↑(Order.succ a)

full_name: WithTop.instIsEmptyPredOrderOfNonempty
code: instance [hα : Nonempty α] : IsEmpty (PredOrder (WithTop α)) 
goal: IsEmpty (PredOrder (WithTop α))

full_name: WithBot.instSuccOrder
code: instance : SuccOrder (WithBot α) 
goal: SuccOrder (WithBot α)

full_name: WithBot.succ_bot
code: @[simp]
theorem succ_bot : succ (⊥ : WithBot α) = ↑(⊥ : α) 
goal: Order.succ ⊥ = ↑⊥

full_name: WithBot.succ_coe
code: @[simp]
theorem succ_coe (a : α) : succ (↑a : WithBot α) = ↑(succ a) 
goal: Order.succ ↑a = ↑(Order.succ a)

full_name: WithBot.succ_unbot
code: @[simp]
theorem succ_unbot :
    ∀ (a : WithBot α) (ha : a ≠ ⊥),
      succ (a.unbot ha) = (succ a).unbot (by induction a <;> simp)
  
goal: Order.succ (a.unbot ha) = (Order.succ a).unbot ⋯

full_name: WithBot.instPredOrder
code: instance : PredOrder (WithBot α) 
goal: PredOrder (WithBot α)

full_name: WithBot.pred_coe_bot
code: @[simp]
theorem pred_coe_bot : pred ↑(⊥ : α) = (⊥ : WithBot α) 
goal: Order.pred ↑⊥ = ⊥

full_name: WithBot.pred_coe_of_ne_bot
code: theorem pred_coe_of_ne_bot {a : α} (h : a ≠ ⊥) : pred (↑a : WithBot α) = ↑(pred a) 
goal: Order.pred ↑a = ↑(Order.pred a)

full_name: WithBot.instIsEmptySuccOrderOfNonempty
code: instance [hα : Nonempty α] : IsEmpty (SuccOrder (WithBot α)) 
goal: IsEmpty (SuccOrder (WithBot α))

full_name: WithBot.predOrderOfNoMinOrder
code: instance predOrderOfNoMinOrder : PredOrder (WithBot α) 
goal: PredOrder (WithBot α)

full_name: WithBot.pred_coe
code: @[simp]
theorem pred_coe (a : α) : pred (↑a : WithBot α) = ↑(pred a) 
goal: Order.pred ↑a = ↑(Order.pred a)

full_name: IsSuccArchimedean.exists_succ_iterate_of_le
code: /-- A `SuccOrder` is succ-archimedean if one can go from any two comparable elements by iterating
`succ` -/
class IsSuccArchimedean (α : Type*) [Preorder α] [SuccOrder α] : Prop where
  /-- If `a ≤ b` then one can get to `a` from `b` by iterating `succ` -/
  exists_succ_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, succ^[n] a = b
goal: ∃ n, Order.succ^[n] a = b

full_name: IsSuccArchimedean
code: /-- A `SuccOrder` is succ-archimedean if one can go from any two comparable elements by iterating
`succ` -/
class IsSuccArchimedean (α : Type*) [Preorder α] [SuccOrder α] : Prop where
  /-- If `a ≤ b` then one can get to `a` from `b` by iterating `succ` -/
  exists_succ_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, succ^[n] a = b
goal: Prop

full_name: IsPredArchimedean.exists_pred_iterate_of_le
code: /-- A `PredOrder` is pred-archimedean if one can go from any two comparable elements by iterating
`pred` -/
class IsPredArchimedean (α : Type*) [Preorder α] [PredOrder α] : Prop where
  /-- If `a ≤ b` then one can get to `b` from `a` by iterating `pred` -/
  exists_pred_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, pred^[n] b = a
goal: ∃ n, Order.pred^[n] b = a

full_name: IsPredArchimedean
code: /-- A `PredOrder` is pred-archimedean if one can go from any two comparable elements by iterating
`pred` -/
class IsPredArchimedean (α : Type*) [Preorder α] [PredOrder α] : Prop where
  /-- If `a ≤ b` then one can get to `b` from `a` by iterating `pred` -/
  exists_pred_iterate_of_le {a b : α} (h : a ≤ b) : ∃ n, pred^[n] b = a
goal: Prop

full_name: instIsPredArchimedeanOrderDual
code: instance : IsPredArchimedean αᵒᵈ 
goal: IsPredArchimedean αᵒᵈ

full_name: LE.le.exists_succ_iterate
code: theorem LE.le.exists_succ_iterate (h : a ≤ b) : ∃ n, succ^[n] a = b 
goal: ∃ n, Order.succ^[n] a = b

full_name: exists_succ_iterate_iff_le
code: theorem exists_succ_iterate_iff_le : (∃ n, succ^[n] a = b) ↔ a ≤ b 
goal: (∃ n, Order.succ^[n] a = b) ↔ a ≤ b

full_name: Succ.rec
code: /-- Induction principle on a type with a `SuccOrder` for all elements above a given element `m`. -/
@[elab_as_elim]
theorem Succ.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, m ≤ n → P n → P (succ n)) ⦃n : α⦄
    (hmn : m ≤ n) : P n 
goal: P n

full_name: Succ.rec_iff
code: theorem Succ.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (succ a)) {a b : α} (h : a ≤ b) :
    p a ↔ p b 
goal: p a ↔ p b

full_name: instIsSuccArchimedeanOrderDual
code: instance : IsSuccArchimedean αᵒᵈ 
goal: IsSuccArchimedean αᵒᵈ

full_name: LE.le.exists_pred_iterate
code: theorem LE.le.exists_pred_iterate (h : a ≤ b) : ∃ n, pred^[n] b = a 
goal: ∃ n, Order.pred^[n] b = a

full_name: exists_pred_iterate_iff_le
code: theorem exists_pred_iterate_iff_le : (∃ n, pred^[n] b = a) ↔ a ≤ b 
goal: (∃ n, Order.pred^[n] b = a) ↔ a ≤ b

full_name: Pred.rec
code: /-- Induction principle on a type with a `PredOrder` for all elements below a given element `m`. -/
@[elab_as_elim]
theorem Pred.rec {P : α → Prop} {m : α} (h0 : P m) (h1 : ∀ n, n ≤ m → P n → P (pred n)) ⦃n : α⦄
    (hmn : n ≤ m) : P n 
goal: P n

full_name: Pred.rec_iff
code: theorem Pred.rec_iff {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) {a b : α} (h : a ≤ b) :
    p a ↔ p b 
goal: p a ↔ p b

full_name: succ_max
code: lemma succ_max (a b : α) : succ (max a b) = max (succ a) (succ b) 
goal: Order.succ (max a b) = max (Order.succ a) (Order.succ b)

full_name: succ_min
code: lemma succ_min (a b : α) : succ (min a b) = min (succ a) (succ b) 
goal: Order.succ (min a b) = min (Order.succ a) (Order.succ b)

full_name: exists_succ_iterate_or
code: theorem exists_succ_iterate_or : (∃ n, succ^[n] a = b) ∨ ∃ n, succ^[n] b = a 
goal: (∃ n, Order.succ^[n] a = b) ∨ ∃ n, Order.succ^[n] b = a

full_name: Succ.rec_linear
code: theorem Succ.rec_linear {p : α → Prop} (hsucc : ∀ a, p a ↔ p (succ a)) (a b : α) : p a ↔ p b 
goal: p a ↔ p b

full_name: pred_max
code: lemma pred_max (a b : α) : pred (max a b) = max (pred a) (pred b) 
goal: Order.pred (max a b) = max (Order.pred a) (Order.pred b)

full_name: pred_min
code: lemma pred_min (a b : α) : pred (min a b) = min (pred a) (pred b) 
goal: Order.pred (min a b) = min (Order.pred a) (Order.pred b)

full_name: exists_pred_iterate_or
code: theorem exists_pred_iterate_or : (∃ n, pred^[n] b = a) ∨ ∃ n, pred^[n] a = b 
goal: (∃ n, Order.pred^[n] b = a) ∨ ∃ n, Order.pred^[n] a = b

full_name: Pred.rec_linear
code: theorem Pred.rec_linear {p : α → Prop} (hsucc : ∀ a, p a ↔ p (pred a)) (a b : α) : p a ↔ p b 
goal: p a ↔ p b

full_name: StrictMono.not_bddAbove_range
code: lemma StrictMono.not_bddAbove_range [NoMaxOrder α] [SuccOrder β] [IsSuccArchimedean β]
    (hf : StrictMono f) : ¬ BddAbove (Set.range f) 
goal: ¬BddAbove (Set.range f)

full_name: StrictMono.not_bddBelow_range
code: lemma StrictMono.not_bddBelow_range [NoMinOrder α] [PredOrder β] [IsPredArchimedean β]
    (hf : StrictMono f) : ¬ BddBelow (Set.range f) 
goal: ¬BddBelow (Set.range f)

full_name: StrictAnti.not_bddAbove_range
code: lemma StrictAnti.not_bddAbove_range [NoMinOrder α] [SuccOrder β] [IsSuccArchimedean β]
    (hf : StrictAnti f) : ¬ BddAbove (Set.range f) 
goal: ¬BddAbove (Set.range f)

full_name: StrictAnti.not_bddBelow_range
code: lemma StrictAnti.not_bddBelow_range [NoMaxOrder α] [PredOrder β] [IsPredArchimedean β]
    (hf : StrictAnti f) : ¬ BddBelow (Set.range f) 
goal: ¬BddBelow (Set.range f)

full_name: IsWellOrder.toIsPredArchimedean
code: instance (priority := 100) IsWellOrder.toIsPredArchimedean [h : IsWellOrder α (· < ·)]
    [PredOrder α] : IsPredArchimedean α 
goal: IsPredArchimedean α

full_name: IsWellOrder.toIsSuccArchimedean
code: instance (priority := 100) IsWellOrder.toIsSuccArchimedean [h : IsWellOrder α (· > ·)]
    [SuccOrder α] : IsSuccArchimedean α 
goal: IsSuccArchimedean α

full_name: Succ.rec_bot
code: theorem Succ.rec_bot (p : α → Prop) (hbot : p ⊥) (hsucc : ∀ a, p a → p (succ a)) (a : α) : p a 
goal: p a

full_name: Pred.rec_top
code: theorem Pred.rec_top (p : α → Prop) (htop : p ⊤) (hpred : ∀ a, p a → p (pred a)) (a : α) : p a 
goal: p a

full_name: SuccOrder.forall_ne_bot_iff
code: lemma SuccOrder.forall_ne_bot_iff
    [Nontrivial α] [PartialOrder α] [OrderBot α] [SuccOrder α] [IsSuccArchimedean α]
    (P : α → Prop) :
    (∀ i, i ≠ ⊥ → P i) ↔ (∀ i, P (SuccOrder.succ i)) 
goal: (∀ (i : α), i ≠ ⊥ → P i) ↔ ∀ (i : α), P (SuccOrder.succ i)