File: Mathlib/Order/Max.lean

full_name: NoBotOrder
code: /-- Order without bottom elements. -/
class NoBotOrder (α : Type*) [LE α] : Prop where
  /-- For each term `a`, there is some `b` which is either incomparable or strictly smaller. -/
  exists_not_ge (a : α) : ∃ b, ¬a ≤ b
goal: Prop

full_name: NoBotOrder.exists_not_ge
code: /-- Order without bottom elements. -/
class NoBotOrder (α : Type*) [LE α] : Prop where
  /-- For each term `a`, there is some `b` which is either incomparable or strictly smaller. -/
  exists_not_ge (a : α) : ∃ b, ¬a ≤ b
goal: ∃ b, ¬a ≤ b

full_name: NoTopOrder
code: /-- Order without top elements. -/
class NoTopOrder (α : Type*) [LE α] : Prop where
  /-- For each term `a`, there is some `b` which is either incomparable or strictly larger. -/
  exists_not_le (a : α) : ∃ b, ¬b ≤ a
goal: Prop

full_name: NoTopOrder.exists_not_le
code: /-- Order without top elements. -/
class NoTopOrder (α : Type*) [LE α] : Prop where
  /-- For each term `a`, there is some `b` which is either incomparable or strictly larger. -/
  exists_not_le (a : α) : ∃ b, ¬b ≤ a
goal: ∃ b, ¬b ≤ a

full_name: NoMinOrder
code: /-- Order without minimal elements. Sometimes called coinitial or dense. -/
class NoMinOrder (α : Type*) [LT α] : Prop where
  /-- For each term `a`, there is some strictly smaller `b`. -/
  exists_lt (a : α) : ∃ b, b < a
goal: Prop

full_name: NoMinOrder.exists_lt
code: /-- Order without minimal elements. Sometimes called coinitial or dense. -/
class NoMinOrder (α : Type*) [LT α] : Prop where
  /-- For each term `a`, there is some strictly smaller `b`. -/
  exists_lt (a : α) : ∃ b, b < a
goal: ∃ b, b < a

full_name: NoMaxOrder.exists_gt
code: /-- Order without maximal elements. Sometimes called cofinal. -/
class NoMaxOrder (α : Type*) [LT α] : Prop where
  /-- For each term `a`, there is some strictly greater `b`. -/
  exists_gt (a : α) : ∃ b, a < b
goal: ∃ b, a < b

full_name: NoMaxOrder
code: /-- Order without maximal elements. Sometimes called cofinal. -/
class NoMaxOrder (α : Type*) [LT α] : Prop where
  /-- For each term `a`, there is some strictly greater `b`. -/
  exists_gt (a : α) : ∃ b, a < b
goal: Prop

full_name: nonempty_lt
code: instance nonempty_lt [LT α] [NoMinOrder α] (a : α) : Nonempty { x // x < a } 
goal: Nonempty { x // x < a }

full_name: nonempty_gt
code: instance nonempty_gt [LT α] [NoMaxOrder α] (a : α) : Nonempty { x // a < x } 
goal: Nonempty { x // a < x }

full_name: IsEmpty.toNoMaxOrder
code: instance IsEmpty.toNoMaxOrder [LT α] [IsEmpty α] : NoMaxOrder α 
goal: NoMaxOrder α

full_name: IsEmpty.toNoMinOrder
code: instance IsEmpty.toNoMinOrder [LT α] [IsEmpty α] : NoMinOrder α 
goal: NoMinOrder α

full_name: OrderDual.noBotOrder
code: instance OrderDual.noBotOrder [LE α] [NoTopOrder α] : NoBotOrder αᵒᵈ 
goal: NoBotOrder αᵒᵈ

full_name: OrderDual.noTopOrder
code: instance OrderDual.noTopOrder [LE α] [NoBotOrder α] : NoTopOrder αᵒᵈ 
goal: NoTopOrder αᵒᵈ

full_name: OrderDual.noMinOrder
code: instance OrderDual.noMinOrder [LT α] [NoMaxOrder α] : NoMinOrder αᵒᵈ 
goal: NoMinOrder αᵒᵈ

full_name: OrderDual.noMaxOrder
code: instance OrderDual.noMaxOrder [LT α] [NoMinOrder α] : NoMaxOrder αᵒᵈ 
goal: NoMaxOrder αᵒᵈ

full_name: instNoBotOrderOfNoMinOrder
code: instance (priority := 100) [Preorder α] [NoMinOrder α] : NoBotOrder α 
goal: NoBotOrder α

full_name: instNoTopOrderOfNoMaxOrder
code: instance (priority := 100) [Preorder α] [NoMaxOrder α] : NoTopOrder α 
goal: NoTopOrder α

full_name: noMaxOrder_of_left
code: instance noMaxOrder_of_left [Preorder α] [Preorder β] [NoMaxOrder α] : NoMaxOrder (α × β) 
goal: NoMaxOrder (α × β)

full_name: noMaxOrder_of_right
code: instance noMaxOrder_of_right [Preorder α] [Preorder β] [NoMaxOrder β] : NoMaxOrder (α × β) 
goal: NoMaxOrder (α × β)

full_name: noMinOrder_of_left
code: instance noMinOrder_of_left [Preorder α] [Preorder β] [NoMinOrder α] : NoMinOrder (α × β) 
goal: NoMinOrder (α × β)

full_name: noMinOrder_of_right
code: instance noMinOrder_of_right [Preorder α] [Preorder β] [NoMinOrder β] : NoMinOrder (α × β) 
goal: NoMinOrder (α × β)

full_name: instNoMaxOrderForallOfNonempty
code: instance {ι : Type u} {π : ι → Type*} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMaxOrder (π i)] :
    NoMaxOrder (∀ i, π i) 
goal: NoMaxOrder ((i : ι) → π i)

full_name: instNoMinOrderForallOfNonempty
code: instance {ι : Type u} {π : ι → Type*} [Nonempty ι] [∀ i, Preorder (π i)] [∀ i, NoMinOrder (π i)] :
    NoMinOrder (∀ i, π i) 
goal: NoMinOrder ((i : ι) → π i)

full_name: NoBotOrder.to_noMinOrder
code: theorem NoBotOrder.to_noMinOrder (α : Type*) [LinearOrder α] [NoBotOrder α] : NoMinOrder α 
goal: NoMinOrder α

full_name: NoTopOrder.to_noMaxOrder
code: theorem NoTopOrder.to_noMaxOrder (α : Type*) [LinearOrder α] [NoTopOrder α] : NoMaxOrder α 
goal: NoMaxOrder α

full_name: noBotOrder_iff_noMinOrder
code: theorem noBotOrder_iff_noMinOrder (α : Type*) [LinearOrder α] : NoBotOrder α ↔ NoMinOrder α 
goal: NoBotOrder α ↔ NoMinOrder α

full_name: noTopOrder_iff_noMaxOrder
code: theorem noTopOrder_iff_noMaxOrder (α : Type*) [LinearOrder α] : NoTopOrder α ↔ NoMaxOrder α 
goal: NoTopOrder α ↔ NoMaxOrder α

full_name: NoMinOrder.not_acc
code: theorem NoMinOrder.not_acc [LT α] [NoMinOrder α] (a : α) : ¬Acc (· < ·) a 
goal: ¬Acc (fun x x_1 => x < x_1) a

full_name: NoMaxOrder.not_acc
code: theorem NoMaxOrder.not_acc [LT α] [NoMaxOrder α] (a : α) : ¬Acc (· > ·) a 
goal: ¬Acc (fun x x_1 => x > x_1) a

full_name: IsBot
code: /-- `a : α` is a bottom element of `α` if it is less than or equal to any other element of `α`.
This predicate is roughly an unbundled version of `OrderBot`, except that a preorder may have
several bottom elements. When `α` is linear, this is useful to make a case disjunction on
`NoMinOrder α` within a proof. -/
def IsBot (a : α) : Prop 
goal: Prop

full_name: IsTop
code: /-- `a : α` is a top element of `α` if it is greater than or equal to any other element of `α`.
This predicate is roughly an unbundled version of `OrderBot`, except that a preorder may have
several top elements. When `α` is linear, this is useful to make a case disjunction on
`NoMaxOrder α` within a proof. -/
def IsTop (a : α) : Prop 
goal: Prop

full_name: IsMin
code: /-- `a` is a minimal element of `α` if no element is strictly less than it. We spell it without `<`
to avoid having to convert between `≤` and `<`. Instead, `isMin_iff_forall_not_lt` does the
conversion. -/
def IsMin (a : α) : Prop 
goal: Prop

full_name: IsMax
code: /-- `a` is a maximal element of `α` if no element is strictly greater than it. We spell it without
`<` to avoid having to convert between `≤` and `<`. Instead, `isMax_iff_forall_not_lt` does the
conversion. -/
def IsMax (a : α) : Prop 
goal: Prop

full_name: not_isBot
code: @[simp]
theorem not_isBot [NoBotOrder α] (a : α) : ¬IsBot a 
goal: ¬IsBot a

full_name: not_isTop
code: @[simp]
theorem not_isTop [NoTopOrder α] (a : α) : ¬IsTop a 
goal: ¬IsTop a

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

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

full_name: isBot_toDual_iff
code: @[simp]
theorem isBot_toDual_iff : IsBot (toDual a) ↔ IsTop a 
goal: IsBot (OrderDual.toDual a) ↔ IsTop a

full_name: isTop_toDual_iff
code: @[simp]
theorem isTop_toDual_iff : IsTop (toDual a) ↔ IsBot a 
goal: IsTop (OrderDual.toDual a) ↔ IsBot a

full_name: isMin_toDual_iff
code: @[simp]
theorem isMin_toDual_iff : IsMin (toDual a) ↔ IsMax a 
goal: IsMin (OrderDual.toDual a) ↔ IsMax a

full_name: isMax_toDual_iff
code: @[simp]
theorem isMax_toDual_iff : IsMax (toDual a) ↔ IsMin a 
goal: IsMax (OrderDual.toDual a) ↔ IsMin a

full_name: isBot_ofDual_iff
code: @[simp]
theorem isBot_ofDual_iff {a : αᵒᵈ} : IsBot (ofDual a) ↔ IsTop a 
goal: IsBot (OrderDual.ofDual a) ↔ IsTop a

full_name: isTop_ofDual_iff
code: @[simp]
theorem isTop_ofDual_iff {a : αᵒᵈ} : IsTop (ofDual a) ↔ IsBot a 
goal: IsTop (OrderDual.ofDual a) ↔ IsBot a

full_name: isMin_ofDual_iff
code: @[simp]
theorem isMin_ofDual_iff {a : αᵒᵈ} : IsMin (ofDual a) ↔ IsMax a 
goal: IsMin (OrderDual.ofDual a) ↔ IsMax a

full_name: isMax_ofDual_iff
code: @[simp]
theorem isMax_ofDual_iff {a : αᵒᵈ} : IsMax (ofDual a) ↔ IsMin a 
goal: IsMax (OrderDual.ofDual a) ↔ IsMin a

full_name: IsBot.mono
code: theorem IsBot.mono (ha : IsBot a) (h : b ≤ a) : IsBot b 
goal: IsBot b

full_name: IsTop.mono
code: theorem IsTop.mono (ha : IsTop a) (h : a ≤ b) : IsTop b 
goal: IsTop b

full_name: IsMin.mono
code: theorem IsMin.mono (ha : IsMin a) (h : b ≤ a) : IsMin b 
goal: IsMin b

full_name: IsMax.mono
code: theorem IsMax.mono (ha : IsMax a) (h : a ≤ b) : IsMax b 
goal: IsMax b

full_name: IsMin.not_lt
code: theorem IsMin.not_lt (h : IsMin a) : ¬b < a 
goal: ¬b < a

full_name: IsMax.not_lt
code: theorem IsMax.not_lt (h : IsMax a) : ¬a < b 
goal: ¬a < b

full_name: not_isMin_of_lt
code: @[simp]
theorem not_isMin_of_lt (h : b < a) : ¬IsMin a 
goal: ¬IsMin a

full_name: not_isMax_of_lt
code: @[simp]
theorem not_isMax_of_lt (h : a < b) : ¬IsMax a 
goal: ¬IsMax a

full_name: isMin_iff_forall_not_lt
code: theorem isMin_iff_forall_not_lt : IsMin a ↔ ∀ b, ¬b < a 
goal: IsMin a ↔ ∀ (b : α), ¬b < a

full_name: isMax_iff_forall_not_lt
code: theorem isMax_iff_forall_not_lt : IsMax a ↔ ∀ b, ¬a < b 
goal: IsMax a ↔ ∀ (b : α), ¬a < b

full_name: not_isMin_iff
code: @[simp]
theorem not_isMin_iff : ¬IsMin a ↔ ∃ b, b < a 
goal: ¬IsMin a ↔ ∃ b, b < a

full_name: not_isMax_iff
code: @[simp]
theorem not_isMax_iff : ¬IsMax a ↔ ∃ b, a < b 
goal: ¬IsMax a ↔ ∃ b, a < b

full_name: not_isMin
code: @[simp]
theorem not_isMin [NoMinOrder α] (a : α) : ¬IsMin a 
goal: ¬IsMin a

full_name: not_isMax
code: @[simp]
theorem not_isMax [NoMaxOrder α] (a : α) : ¬IsMax a 
goal: ¬IsMax a

full_name: Subsingleton.isBot
code: protected theorem isBot (a : α) : IsBot a 
goal: IsBot a

full_name: Subsingleton.isTop
code: protected theorem isTop (a : α) : IsTop a 
goal: IsTop a

full_name: Subsingleton.isMin
code: protected theorem isMin (a : α) : IsMin a 
goal: IsMin a

full_name: Subsingleton.isMax
code: protected theorem isMax (a : α) : IsMax a 
goal: IsMax a

full_name: IsMin.eq_of_le
code: protected theorem IsMin.eq_of_le (ha : IsMin a) (h : b ≤ a) : b = a 
goal: b = a

full_name: IsMin.eq_of_ge
code: protected theorem IsMin.eq_of_ge (ha : IsMin a) (h : b ≤ a) : a = b 
goal: a = b

full_name: IsMax.eq_of_le
code: protected theorem IsMax.eq_of_le (ha : IsMax a) (h : a ≤ b) : a = b 
goal: a = b

full_name: IsMax.eq_of_ge
code: protected theorem IsMax.eq_of_ge (ha : IsMax a) (h : a ≤ b) : b = a 
goal: b = a

full_name: IsBot.prod_mk
code: theorem IsBot.prod_mk (ha : IsBot a) (hb : IsBot b) : IsBot (a, b) 
goal: IsBot (a, b)

full_name: IsTop.prod_mk
code: theorem IsTop.prod_mk (ha : IsTop a) (hb : IsTop b) : IsTop (a, b) 
goal: IsTop (a, b)

full_name: IsMin.prod_mk
code: theorem IsMin.prod_mk (ha : IsMin a) (hb : IsMin b) : IsMin (a, b) 
goal: IsMin (a, b)

full_name: IsMax.prod_mk
code: theorem IsMax.prod_mk (ha : IsMax a) (hb : IsMax b) : IsMax (a, b) 
goal: IsMax (a, b)

full_name: IsBot.fst
code: theorem IsBot.fst (hx : IsBot x) : IsBot x.1 
goal: IsBot x.1

full_name: IsBot.snd
code: theorem IsBot.snd (hx : IsBot x) : IsBot x.2 
goal: IsBot x.2

full_name: IsTop.fst
code: theorem IsTop.fst (hx : IsTop x) : IsTop x.1 
goal: IsTop x.1

full_name: IsTop.snd
code: theorem IsTop.snd (hx : IsTop x) : IsTop x.2 
goal: IsTop x.2

full_name: IsMin.fst
code: theorem IsMin.fst (hx : IsMin x) : IsMin x.1 
goal: IsMin x.1

full_name: IsMin.snd
code: theorem IsMin.snd (hx : IsMin x) : IsMin x.2 
goal: IsMin x.2

full_name: IsMax.fst
code: theorem IsMax.fst (hx : IsMax x) : IsMax x.1 
goal: IsMax x.1

full_name: IsMax.snd
code: theorem IsMax.snd (hx : IsMax x) : IsMax x.2 
goal: IsMax x.2

full_name: Prod.isBot_iff
code: theorem Prod.isBot_iff : IsBot x ↔ IsBot x.1 ∧ IsBot x.2 
goal: IsBot x ↔ IsBot x.1 ∧ IsBot x.2

full_name: Prod.isTop_iff
code: theorem Prod.isTop_iff : IsTop x ↔ IsTop x.1 ∧ IsTop x.2 
goal: IsTop x ↔ IsTop x.1 ∧ IsTop x.2

full_name: Prod.isMin_iff
code: theorem Prod.isMin_iff : IsMin x ↔ IsMin x.1 ∧ IsMin x.2 
goal: IsMin x ↔ IsMin x.1 ∧ IsMin x.2

full_name: Prod.isMax_iff
code: theorem Prod.isMax_iff : IsMax x ↔ IsMax x.1 ∧ IsMax x.2 
goal: IsMax x ↔ IsMax x.1 ∧ IsMax x.2