File: Mathlib/Order/SuccPred/Limit.lean

full_name: Order.IsSuccLimit
code: /-- A successor limit is a value that doesn't cover any other.

It's so named because in a successor order, a successor limit can't be the successor of anything
smaller. -/
def IsSuccLimit (a : α) : Prop 
goal: Prop

full_name: Order.not_isSuccLimit_iff_exists_covBy
code: theorem not_isSuccLimit_iff_exists_covBy (a : α) : ¬IsSuccLimit a ↔ ∃ b, b ⋖ a 
goal: ¬Order.IsSuccLimit a ↔ ∃ b, b ⋖ a

full_name: Order.isSuccLimit_of_dense
code: @[simp]
theorem isSuccLimit_of_dense [DenselyOrdered α] (a : α) : IsSuccLimit a 
goal: Order.IsSuccLimit a

full_name: IsMin.isSuccLimit
code: protected theorem _root_.IsMin.isSuccLimit : IsMin a → IsSuccLimit a 
goal: IsMin a → Order.IsSuccLimit a

full_name: Order.isSuccLimit_bot
code: theorem isSuccLimit_bot [OrderBot α] : IsSuccLimit (⊥ : α) 
goal: Order.IsSuccLimit ⊥

full_name: Order.IsSuccLimit.isMax
code: protected theorem IsSuccLimit.isMax (h : IsSuccLimit (succ a)) : IsMax a 
goal: IsMax a

full_name: Order.not_isSuccLimit_succ_of_not_isMax
code: theorem not_isSuccLimit_succ_of_not_isMax (ha : ¬IsMax a) : ¬IsSuccLimit (succ a) 
goal: ¬Order.IsSuccLimit (Order.succ a)

full_name: Order.IsSuccLimit.succ_ne
code: theorem IsSuccLimit.succ_ne (h : IsSuccLimit a) (b : α) : succ b ≠ a 
goal: Order.succ b ≠ a

full_name: Order.not_isSuccLimit_succ
code: @[simp]
theorem not_isSuccLimit_succ (a : α) : ¬IsSuccLimit (succ a) 
goal: ¬Order.IsSuccLimit (Order.succ a)

full_name: Order.IsSuccLimit.isMin_of_noMax
code: theorem IsSuccLimit.isMin_of_noMax [NoMaxOrder α] (h : IsSuccLimit a) : IsMin a 
goal: IsMin a

full_name: Order.isSuccLimit_iff_of_noMax
code: @[simp]
theorem isSuccLimit_iff_of_noMax [NoMaxOrder α] : IsSuccLimit a ↔ IsMin a 
goal: Order.IsSuccLimit a ↔ IsMin a

full_name: Order.not_isSuccLimit_of_noMax
code: theorem not_isSuccLimit_of_noMax [NoMinOrder α] [NoMaxOrder α] : ¬IsSuccLimit a 
goal: ¬Order.IsSuccLimit a

full_name: Order.isSuccLimit_of_succ_ne
code: theorem isSuccLimit_of_succ_ne (h : ∀ b, succ b ≠ a) : IsSuccLimit a 
goal: Order.IsSuccLimit a

full_name: Order.not_isSuccLimit_iff
code: theorem not_isSuccLimit_iff : ¬IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ succ b = a 
goal: ¬Order.IsSuccLimit a ↔ ∃ b, ¬IsMax b ∧ Order.succ b = a

full_name: Order.mem_range_succ_of_not_isSuccLimit
code: /-- See `not_isSuccLimit_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 α _ _) 
goal: a ∈ Set.range Order.succ

full_name: Order.isSuccLimit_of_succ_lt
code: theorem isSuccLimit_of_succ_lt (H : ∀ a < b, succ a < b) : IsSuccLimit b 
goal: Order.IsSuccLimit b

full_name: Order.IsSuccLimit.succ_lt
code: theorem IsSuccLimit.succ_lt (hb : IsSuccLimit b) (ha : a < b) : succ a < b 
goal: Order.succ a < b

full_name: Order.IsSuccLimit.succ_lt_iff
code: theorem IsSuccLimit.succ_lt_iff (hb : IsSuccLimit b) : succ a < b ↔ a < b 
goal: Order.succ a < b ↔ a < b

full_name: Order.isSuccLimit_iff_succ_lt
code: theorem isSuccLimit_iff_succ_lt : IsSuccLimit b ↔ ∀ a < b, succ a < b 
goal: Order.IsSuccLimit b ↔ ∀ a < b, Order.succ a < b

full_name: Order.isSuccLimitRecOn
code: /-- 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))
    (hl : ∀ a, IsSuccLimit a → C a) : C b 
goal: C b

full_name: Order.isSuccLimitRecOn_limit
code: 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 
goal: Order.isSuccLimitRecOn b hs hl = hl b hb

full_name: Order.isSuccLimitRecOn_succ'
code: 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 
goal: Order.isSuccLimitRecOn (Order.succ b) hs hl = hs b hb

full_name: SuccOrder.limitRecOn
code: /-- Recursion principle on a well-founded partial `SuccOrder`. -/
@[elab_as_elim] noncomputable def _root_.SuccOrder.limitRecOn : C a 
goal: C a

full_name: SuccOrder.limitRecOn_succ
code: @[simp]
theorem _root_.SuccOrder.limitRecOn_succ (ha : ¬ IsMax a) :
    SuccOrder.limitRecOn (succ a) H_succ H_lim
      = H_succ a ha (SuccOrder.limitRecOn a H_succ H_lim) 
goal: SuccOrder.limitRecOn (Order.succ a) H_succ H_lim = H_succ a ha (SuccOrder.limitRecOn a H_succ H_lim)

full_name: SuccOrder.limitRecOn_limit
code: @[simp]
theorem _root_.SuccOrder.limitRecOn_limit (ha : IsSuccLimit a) :
    SuccOrder.limitRecOn a H_succ H_lim
      = H_lim a ha fun x _ ↦ SuccOrder.limitRecOn x H_succ H_lim 
goal: SuccOrder.limitRecOn a H_succ H_lim = H_lim a ha fun x x_1 => SuccOrder.limitRecOn x H_succ H_lim

full_name: Order.isSuccLimitRecOn_succ
code: @[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) 
goal: Order.isSuccLimitRecOn (Order.succ b) hs hl = hs b ⋯

full_name: Order.isSuccLimit_iff_succ_ne
code: theorem isSuccLimit_iff_succ_ne : IsSuccLimit a ↔ ∀ b, succ b ≠ a 
goal: Order.IsSuccLimit a ↔ ∀ (b : α), Order.succ b ≠ a

full_name: Order.not_isSuccLimit_iff'
code: theorem not_isSuccLimit_iff' : ¬IsSuccLimit a ↔ a ∈ range (@succ α _ _) 
goal: ¬Order.IsSuccLimit a ↔ a ∈ Set.range Order.succ

full_name: Order.IsSuccLimit.isMin
code: protected theorem IsSuccLimit.isMin (h : IsSuccLimit a) : IsMin a 
goal: IsMin a

full_name: Order.isSuccLimit_iff
code: @[simp]
theorem isSuccLimit_iff : IsSuccLimit a ↔ IsMin a 
goal: Order.IsSuccLimit a ↔ IsMin a

full_name: Order.not_isSuccLimit
code: theorem not_isSuccLimit [NoMinOrder α] : ¬IsSuccLimit a 
goal: ¬Order.IsSuccLimit a

full_name: Order.IsPredLimit
code: /-- A predecessor limit is a value that isn't covered by any other.

It's so named because in a predecessor order, a predecessor limit can't be the predecessor of
anything greater. -/
def IsPredLimit (a : α) : Prop 
goal: Prop

full_name: Order.not_isPredLimit_iff_exists_covBy
code: theorem not_isPredLimit_iff_exists_covBy (a : α) : ¬IsPredLimit a ↔ ∃ b, a ⋖ b 
goal: ¬Order.IsPredLimit a ↔ ∃ b, a ⋖ b

full_name: Order.isPredLimit_of_dense
code: theorem isPredLimit_of_dense [DenselyOrdered α] (a : α) : IsPredLimit a 
goal: Order.IsPredLimit a

full_name: Order.isSuccLimit_toDual_iff
code: @[simp]
theorem isSuccLimit_toDual_iff : IsSuccLimit (toDual a) ↔ IsPredLimit a 
goal: Order.IsSuccLimit (OrderDual.toDual a) ↔ Order.IsPredLimit a

full_name: Order.isPredLimit_toDual_iff
code: @[simp]
theorem isPredLimit_toDual_iff : IsPredLimit (toDual a) ↔ IsSuccLimit a 
goal: Order.IsPredLimit (OrderDual.toDual a) ↔ Order.IsSuccLimit a

full_name: IsMax.isPredLimit
code: protected theorem _root_.IsMax.isPredLimit : IsMax a → IsPredLimit a 
goal: IsMax a → Order.IsPredLimit a

full_name: Order.isPredLimit_top
code: theorem isPredLimit_top [OrderTop α] : IsPredLimit (⊤ : α) 
goal: Order.IsPredLimit ⊤

full_name: Order.IsPredLimit.isMin
code: protected theorem IsPredLimit.isMin (h : IsPredLimit (pred a)) : IsMin a 
goal: IsMin a

full_name: Order.not_isPredLimit_pred_of_not_isMin
code: theorem not_isPredLimit_pred_of_not_isMin (ha : ¬IsMin a) : ¬IsPredLimit (pred a) 
goal: ¬Order.IsPredLimit (Order.pred a)

full_name: Order.IsPredLimit.pred_ne
code: theorem IsPredLimit.pred_ne (h : IsPredLimit a) (b : α) : pred b ≠ a 
goal: Order.pred b ≠ a

full_name: Order.not_isPredLimit_pred
code: @[simp]
theorem not_isPredLimit_pred (a : α) : ¬IsPredLimit (pred a) 
goal: ¬Order.IsPredLimit (Order.pred a)

full_name: Order.IsPredLimit.isMax_of_noMin
code: protected theorem IsPredLimit.isMax_of_noMin [NoMinOrder α] (h : IsPredLimit a) : IsMax a 
goal: IsMax a

full_name: Order.isPredLimit_iff_of_noMin
code: @[simp]
theorem isPredLimit_iff_of_noMin [NoMinOrder α] : IsPredLimit a ↔ IsMax a 
goal: Order.IsPredLimit a ↔ IsMax a

full_name: Order.not_isPredLimit_of_noMin
code: theorem not_isPredLimit_of_noMin [NoMinOrder α] [NoMaxOrder α] : ¬IsPredLimit a 
goal: ¬Order.IsPredLimit a

full_name: Order.isPredLimit_of_pred_ne
code: theorem isPredLimit_of_pred_ne (h : ∀ b, pred b ≠ a) : IsPredLimit a 
goal: Order.IsPredLimit a

full_name: Order.not_isPredLimit_iff
code: theorem not_isPredLimit_iff : ¬IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ pred b = a 
goal: ¬Order.IsPredLimit a ↔ ∃ b, ¬IsMin b ∧ Order.pred b = a

full_name: Order.mem_range_pred_of_not_isPredLimit
code: /-- See `not_isPredLimit_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 α _ _) 
goal: a ∈ Set.range Order.pred

full_name: Order.isPredLimit_of_pred_lt
code: theorem isPredLimit_of_pred_lt (H : ∀ a > b, pred a < b) : IsPredLimit b 
goal: Order.IsPredLimit b

full_name: Order.IsPredLimit.lt_pred
code: theorem IsPredLimit.lt_pred (h : IsPredLimit a) : a < b → a < pred b 
goal: a < b → a < Order.pred b

full_name: Order.IsPredLimit.lt_pred_iff
code: theorem IsPredLimit.lt_pred_iff (h : IsPredLimit a) : a < pred b ↔ a < b 
goal: a < Order.pred b ↔ a < b

full_name: Order.isPredLimit_iff_lt_pred
code: theorem isPredLimit_iff_lt_pred : IsPredLimit a ↔ ∀ ⦃b⦄, a < b → a < pred b 
goal: Order.IsPredLimit a ↔ ∀ ⦃b : α⦄, a < b → a < Order.pred b

full_name: Order.isPredLimitRecOn
code: /-- 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 
goal: C b

full_name: Order.isPredLimitRecOn_limit
code: 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 
goal: Order.isPredLimitRecOn b hs hl = hl b hb

full_name: Order.isPredLimitRecOn_pred'
code: 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 
goal: Order.isPredLimitRecOn (Order.pred b) hs hl = hs b hb

full_name: PredOrder.limitRecOn
code: /-- Recursion principle on a well-founded partial `PredOrder`. -/
@[elab_as_elim] noncomputable def _root_.PredOrder.limitRecOn : C a 
goal: C a

full_name: PredOrder.limitRecOn_pred
code: @[simp]
theorem _root_.PredOrder.limitRecOn_pred (ha : ¬ IsMin a) :
    PredOrder.limitRecOn (pred a) H_pred H_lim
      = H_pred a ha (PredOrder.limitRecOn a H_pred H_lim) 
goal: PredOrder.limitRecOn (Order.pred a) H_pred H_lim = H_pred a ha (PredOrder.limitRecOn a H_pred H_lim)

full_name: PredOrder.limitRecOn_limit
code: @[simp]
theorem _root_.PredOrder.limitRecOn_limit (ha : IsPredLimit a) :
    PredOrder.limitRecOn a H_pred H_lim
      = H_lim a ha fun x _ ↦ PredOrder.limitRecOn x H_pred H_lim 
goal: PredOrder.limitRecOn a H_pred H_lim = H_lim a ha fun x x_1 => PredOrder.limitRecOn x H_pred H_lim

full_name: Order.isPredLimitRecOn_pred
code: @[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) 
goal: Order.isPredLimitRecOn (Order.pred b) hs hl = hs b ⋯

full_name: Order.IsPredLimit.isMax
code: protected theorem IsPredLimit.isMax (h : IsPredLimit a) : IsMax a 
goal: IsMax a

full_name: Order.isPredLimit_iff
code: @[simp]
theorem isPredLimit_iff : IsPredLimit a ↔ IsMax a 
goal: Order.IsPredLimit a ↔ IsMax a

full_name: Order.not_isPredLimit
code: theorem not_isPredLimit [NoMaxOrder α] : ¬IsPredLimit a 
goal: ¬Order.IsPredLimit a