File: Mathlib/Order/BoundedOrder.lean

full_name: OrderTop
code: /-- An order is an `OrderTop` if it has a greatest element.
We state this using a data mixin, holding the value of `⊤` and the greatest element constraint. -/
class OrderTop (α : Type u) [LE α] extends Top α where
  /-- `⊤` is the greatest element -/
  le_top : ∀ a : α, a ≤ ⊤
goal: Type u

full_name: OrderTop.le_top
code: /-- An order is an `OrderTop` if it has a greatest element.
We state this using a data mixin, holding the value of `⊤` and the greatest element constraint. -/
class OrderTop (α : Type u) [LE α] extends Top α where
  /-- `⊤` is the greatest element -/
  le_top : ∀ a : α, a ≤ ⊤
goal: a ≤ ⊤

full_name: topOrderOrNoTopOrder
code: /-- An order is (noncomputably) either an `OrderTop` or a `NoTopOrder`. Use as
`casesI topOrderOrNoTopOrder α`. -/
noncomputable def topOrderOrNoTopOrder (α : Type*) [LE α] : OrderTop α ⊕' NoTopOrder α 
goal: OrderTop α ⊕' NoTopOrder α

full_name: le_top
code: @[simp]
theorem le_top : a ≤ ⊤ 
goal: a ≤ ⊤

full_name: isTop_top
code: @[simp]
theorem isTop_top : IsTop (⊤ : α) 
goal: IsTop ⊤

full_name: isMax_top
code: @[simp]
theorem isMax_top : IsMax (⊤ : α) 
goal: IsMax ⊤

full_name: not_top_lt
code: @[simp]
theorem not_top_lt : ¬⊤ < a 
goal: ¬⊤ < a

full_name: ne_top_of_lt
code: theorem ne_top_of_lt (h : a < b) : a ≠ ⊤ 
goal: a ≠ ⊤

full_name: isMax_iff_eq_top
code: @[simp]
theorem isMax_iff_eq_top : IsMax a ↔ a = ⊤ 
goal: IsMax a ↔ a = ⊤

full_name: isTop_iff_eq_top
code: @[simp]
theorem isTop_iff_eq_top : IsTop a ↔ a = ⊤ 
goal: IsTop a ↔ a = ⊤

full_name: not_isMax_iff_ne_top
code: theorem not_isMax_iff_ne_top : ¬IsMax a ↔ a ≠ ⊤ 
goal: ¬IsMax a ↔ a ≠ ⊤

full_name: not_isTop_iff_ne_top
code: theorem not_isTop_iff_ne_top : ¬IsTop a ↔ a ≠ ⊤ 
goal: ¬IsTop a ↔ a ≠ ⊤

full_name: top_le_iff
code: @[simp]
theorem top_le_iff : ⊤ ≤ a ↔ a = ⊤ 
goal: ⊤ ≤ a ↔ a = ⊤

full_name: top_unique
code: theorem top_unique (h : ⊤ ≤ a) : a = ⊤ 
goal: a = ⊤

full_name: eq_top_iff
code: theorem eq_top_iff : a = ⊤ ↔ ⊤ ≤ a 
goal: a = ⊤ ↔ ⊤ ≤ a

full_name: eq_top_mono
code: theorem eq_top_mono (h : a ≤ b) (h₂ : a = ⊤) : b = ⊤ 
goal: b = ⊤

full_name: lt_top_iff_ne_top
code: theorem lt_top_iff_ne_top : a < ⊤ ↔ a ≠ ⊤ 
goal: a < ⊤ ↔ a ≠ ⊤

full_name: not_lt_top_iff
code: @[simp]
theorem not_lt_top_iff : ¬a < ⊤ ↔ a = ⊤ 
goal: ¬a < ⊤ ↔ a = ⊤

full_name: eq_top_or_lt_top
code: theorem eq_top_or_lt_top (a : α) : a = ⊤ ∨ a < ⊤ 
goal: a = ⊤ ∨ a < ⊤

full_name: Ne.lt_top
code: theorem Ne.lt_top (h : a ≠ ⊤) : a < ⊤ 
goal: a < ⊤

full_name: Ne.lt_top'
code: theorem Ne.lt_top' (h : ⊤ ≠ a) : a < ⊤ 
goal: a < ⊤

full_name: ne_top_of_le_ne_top
code: theorem ne_top_of_le_ne_top (hb : b ≠ ⊤) (hab : a ≤ b) : a ≠ ⊤ 
goal: a ≠ ⊤

full_name: StrictMono.apply_eq_top_iff
code: theorem StrictMono.apply_eq_top_iff (hf : StrictMono f) : f a = f ⊤ ↔ a = ⊤ 
goal: f a = f ⊤ ↔ a = ⊤

full_name: StrictAnti.apply_eq_top_iff
code: theorem StrictAnti.apply_eq_top_iff (hf : StrictAnti f) : f a = f ⊤ ↔ a = ⊤ 
goal: f a = f ⊤ ↔ a = ⊤

full_name: not_isMin_top
code: theorem not_isMin_top : ¬IsMin (⊤ : α) 
goal: ¬IsMin ⊤

full_name: StrictMono.maximal_preimage_top
code: theorem StrictMono.maximal_preimage_top [LinearOrder α] [Preorder β] [OrderTop β] {f : α → β}
    (H : StrictMono f) {a} (h_top : f a = ⊤) (x : α) : x ≤ a 
goal: x ≤ a

full_name: OrderTop.ext_top
code: theorem OrderTop.ext_top {α} {hA : PartialOrder α} (A : OrderTop α) {hB : PartialOrder α}
    (B : OrderTop α) (H : ∀ x y : α, (haveI := hA; x ≤ y) ↔ x ≤ y) :
    (@Top.top α (@OrderTop.toTop α hA.toLE A)) = (@Top.top α (@OrderTop.toTop α hB.toLE B)) 
goal: ⊤ = ⊤

full_name: OrderBot.bot_le
code: /-- An order is an `OrderBot` if it has a least element.
We state this using a data mixin, holding the value of `⊥` and the least element constraint. -/
class OrderBot (α : Type u) [LE α] extends Bot α where
  /-- `⊥` is the least element -/
  bot_le : ∀ a : α, ⊥ ≤ a
goal: ⊥ ≤ a

full_name: OrderBot
code: /-- An order is an `OrderBot` if it has a least element.
We state this using a data mixin, holding the value of `⊥` and the least element constraint. -/
class OrderBot (α : Type u) [LE α] extends Bot α where
  /-- `⊥` is the least element -/
  bot_le : ∀ a : α, ⊥ ≤ a
goal: Type u

full_name: botOrderOrNoBotOrder
code: /-- An order is (noncomputably) either an `OrderBot` or a `NoBotOrder`. Use as
`casesI botOrderOrNoBotOrder α`. -/
noncomputable def botOrderOrNoBotOrder (α : Type*) [LE α] : OrderBot α ⊕' NoBotOrder α 
goal: OrderBot α ⊕' NoBotOrder α

full_name: bot_le
code: @[simp]
theorem bot_le : ⊥ ≤ a 
goal: ⊥ ≤ a

full_name: isBot_bot
code: @[simp]
theorem isBot_bot : IsBot (⊥ : α) 
goal: IsBot ⊥

full_name: OrderDual.instTop
code: instance instTop [Bot α] : Top αᵒᵈ 
goal: Top αᵒᵈ

full_name: OrderDual.instBot
code: instance instBot [Top α] : Bot αᵒᵈ 
goal: Bot αᵒᵈ

full_name: OrderDual.instOrderTop
code: instance instOrderTop [LE α] [OrderBot α] : OrderTop αᵒᵈ 
goal: OrderTop αᵒᵈ

full_name: OrderDual.instOrderBot
code: instance instOrderBot [LE α] [OrderTop α] : OrderBot αᵒᵈ 
goal: OrderBot αᵒᵈ

full_name: OrderDual.ofDual_bot
code: @[simp]
theorem ofDual_bot [Top α] : ofDual ⊥ = (⊤ : α) 
goal: OrderDual.ofDual ⊥ = ⊤

full_name: OrderDual.ofDual_top
code: @[simp]
theorem ofDual_top [Bot α] : ofDual ⊤ = (⊥ : α) 
goal: OrderDual.ofDual ⊤ = ⊥

full_name: OrderDual.toDual_bot
code: @[simp]
theorem toDual_bot [Bot α] : toDual (⊥ : α) = ⊤ 
goal: OrderDual.toDual ⊥ = ⊤

full_name: OrderDual.toDual_top
code: @[simp]
theorem toDual_top [Top α] : toDual (⊤ : α) = ⊥ 
goal: OrderDual.toDual ⊤ = ⊥

full_name: isMin_bot
code: @[simp]
theorem isMin_bot : IsMin (⊥ : α) 
goal: IsMin ⊥

full_name: not_lt_bot
code: @[simp]
theorem not_lt_bot : ¬a < ⊥ 
goal: ¬a < ⊥

full_name: ne_bot_of_gt
code: theorem ne_bot_of_gt (h : a < b) : b ≠ ⊥ 
goal: b ≠ ⊥

full_name: isMin_iff_eq_bot
code: @[simp]
theorem isMin_iff_eq_bot : IsMin a ↔ a = ⊥ 
goal: IsMin a ↔ a = ⊥

full_name: isBot_iff_eq_bot
code: @[simp]
theorem isBot_iff_eq_bot : IsBot a ↔ a = ⊥ 
goal: IsBot a ↔ a = ⊥

full_name: not_isMin_iff_ne_bot
code: theorem not_isMin_iff_ne_bot : ¬IsMin a ↔ a ≠ ⊥ 
goal: ¬IsMin a ↔ a ≠ ⊥

full_name: not_isBot_iff_ne_bot
code: theorem not_isBot_iff_ne_bot : ¬IsBot a ↔ a ≠ ⊥ 
goal: ¬IsBot a ↔ a ≠ ⊥

full_name: le_bot_iff
code: @[simp]
theorem le_bot_iff : a ≤ ⊥ ↔ a = ⊥ 
goal: a ≤ ⊥ ↔ a = ⊥

full_name: bot_unique
code: theorem bot_unique (h : a ≤ ⊥) : a = ⊥ 
goal: a = ⊥

full_name: eq_bot_iff
code: theorem eq_bot_iff : a = ⊥ ↔ a ≤ ⊥ 
goal: a = ⊥ ↔ a ≤ ⊥

full_name: eq_bot_mono
code: theorem eq_bot_mono (h : a ≤ b) (h₂ : b = ⊥) : a = ⊥ 
goal: a = ⊥

full_name: bot_lt_iff_ne_bot
code: theorem bot_lt_iff_ne_bot : ⊥ < a ↔ a ≠ ⊥ 
goal: ⊥ < a ↔ a ≠ ⊥

full_name: not_bot_lt_iff
code: @[simp]
theorem not_bot_lt_iff : ¬⊥ < a ↔ a = ⊥ 
goal: ¬⊥ < a ↔ a = ⊥

full_name: eq_bot_or_bot_lt
code: theorem eq_bot_or_bot_lt (a : α) : a = ⊥ ∨ ⊥ < a 
goal: a = ⊥ ∨ ⊥ < a

full_name: eq_bot_of_minimal
code: theorem eq_bot_of_minimal (h : ∀ b, ¬b < a) : a = ⊥ 
goal: a = ⊥

full_name: Ne.bot_lt
code: theorem Ne.bot_lt (h : a ≠ ⊥) : ⊥ < a 
goal: ⊥ < a

full_name: Ne.bot_lt'
code: theorem Ne.bot_lt' (h : ⊥ ≠ a) : ⊥ < a 
goal: ⊥ < a

full_name: ne_bot_of_le_ne_bot
code: theorem ne_bot_of_le_ne_bot (hb : b ≠ ⊥) (hab : b ≤ a) : a ≠ ⊥ 
goal: a ≠ ⊥

full_name: StrictMono.apply_eq_bot_iff
code: theorem StrictMono.apply_eq_bot_iff (hf : StrictMono f) : f a = f ⊥ ↔ a = ⊥ 
goal: f a = f ⊥ ↔ a = ⊥

full_name: StrictAnti.apply_eq_bot_iff
code: theorem StrictAnti.apply_eq_bot_iff (hf : StrictAnti f) : f a = f ⊥ ↔ a = ⊥ 
goal: f a = f ⊥ ↔ a = ⊥

full_name: not_isMax_bot
code: theorem not_isMax_bot : ¬IsMax (⊥ : α) 
goal: ¬IsMax ⊥

full_name: StrictMono.minimal_preimage_bot
code: theorem StrictMono.minimal_preimage_bot [LinearOrder α] [PartialOrder β] [OrderBot β] {f : α → β}
    (H : StrictMono f) {a} (h_bot : f a = ⊥) (x : α) : a ≤ x 
goal: a ≤ x

full_name: OrderBot.ext_bot
code: theorem OrderBot.ext_bot {α} {hA : PartialOrder α} (A : OrderBot α) {hB : PartialOrder α}
    (B : OrderBot α) (H : ∀ x y : α, (haveI := hA; x ≤ y) ↔ x ≤ y) :
    (@Bot.bot α (@OrderBot.toBot α hA.toLE A)) = (@Bot.bot α (@OrderBot.toBot α hB.toLE B)) 
goal: ⊥ = ⊥

full_name: top_sup_eq
code: theorem top_sup_eq (a : α) : ⊤ ⊔ a = ⊤ 
goal: ⊤ ⊔ a = ⊤

full_name: sup_top_eq
code: theorem sup_top_eq (a : α) : a ⊔ ⊤ = ⊤ 
goal: a ⊔ ⊤ = ⊤

full_name: bot_sup_eq
code: theorem bot_sup_eq (a : α) : ⊥ ⊔ a = a 
goal: ⊥ ⊔ a = a

full_name: sup_bot_eq
code: theorem sup_bot_eq (a : α) : a ⊔ ⊥ = a 
goal: a ⊔ ⊥ = a

full_name: sup_eq_bot_iff
code: @[simp]
theorem sup_eq_bot_iff : a ⊔ b = ⊥ ↔ a = ⊥ ∧ b = ⊥ 
goal: a ⊔ b = ⊥ ↔ a = ⊥ ∧ b = ⊥

full_name: top_inf_eq
code: lemma top_inf_eq (a : α) : ⊤ ⊓ a = a 
goal: ⊤ ⊓ a = a

full_name: inf_top_eq
code: lemma inf_top_eq (a : α) : a ⊓ ⊤ = a 
goal: a ⊓ ⊤ = a

full_name: inf_eq_top_iff
code: @[simp]
theorem inf_eq_top_iff : a ⊓ b = ⊤ ↔ a = ⊤ ∧ b = ⊤ 
goal: a ⊓ b = ⊤ ↔ a = ⊤ ∧ b = ⊤

full_name: bot_inf_eq
code: lemma bot_inf_eq (a : α) : ⊥ ⊓ a = ⊥ 
goal: ⊥ ⊓ a = ⊥

full_name: inf_bot_eq
code: lemma inf_bot_eq (a : α) : a ⊓ ⊥ = ⊥ 
goal: a ⊓ ⊥ = ⊥

full_name: BoundedOrder
code: /-- A bounded order describes an order `(≤)` with a top and bottom element,
  denoted `⊤` and `⊥` respectively. -/
class BoundedOrder (α : Type u) [LE α] extends OrderTop α, OrderBot α
goal: Type u

full_name: OrderDual.instBoundedOrder
code: instance OrderDual.instBoundedOrder (α : Type u) [LE α] [BoundedOrder α] : BoundedOrder αᵒᵈ 
goal: BoundedOrder αᵒᵈ

full_name: OrderBot.instSubsingleton
code: instance OrderBot.instSubsingleton : Subsingleton (OrderBot α) 
goal: Subsingleton (OrderBot α)

full_name: OrderTop.instSubsingleton
code: instance OrderTop.instSubsingleton : Subsingleton (OrderTop α) 
goal: Subsingleton (OrderTop α)

full_name: BoundedOrder.instSubsingleton
code: instance BoundedOrder.instSubsingleton : Subsingleton (BoundedOrder α) 
goal: Subsingleton (BoundedOrder α)

full_name: monotone_and
code: theorem monotone_and {p q : α → Prop} (m_p : Monotone p) (m_q : Monotone q) :
    Monotone fun x => p x ∧ q x 
goal: Monotone fun x => p x ∧ q x

full_name: monotone_or
code: theorem monotone_or {p q : α → Prop} (m_p : Monotone p) (m_q : Monotone q) :
    Monotone fun x => p x ∨ q x 
goal: Monotone fun x => p x ∨ q x

full_name: monotone_le
code: theorem monotone_le {x : α} : Monotone (x ≤ ·) 
goal: Monotone fun x_1 => x ≤ x_1

full_name: monotone_lt
code: theorem monotone_lt {x : α} : Monotone (x < ·) 
goal: Monotone fun x_1 => x < x_1

full_name: antitone_le
code: theorem antitone_le {x : α} : Antitone (· ≤ x) 
goal: Antitone fun x_1 => x_1 ≤ x

full_name: antitone_lt
code: theorem antitone_lt {x : α} : Antitone (· < x) 
goal: Antitone fun x_1 => x_1 < x

full_name: Monotone.forall
code: theorem Monotone.forall {P : β → α → Prop} (hP : ∀ x, Monotone (P x)) :
    Monotone fun y => ∀ x, P x y 
goal: Monotone fun y => ∀ (x : β), P x y

full_name: Antitone.forall
code: theorem Antitone.forall {P : β → α → Prop} (hP : ∀ x, Antitone (P x)) :
    Antitone fun y => ∀ x, P x y 
goal: Antitone fun y => ∀ (x : β), P x y

full_name: Monotone.ball
code: theorem Monotone.ball {P : β → α → Prop} {s : Set β} (hP : ∀ x ∈ s, Monotone (P x)) :
    Monotone fun y => ∀ x ∈ s, P x y 
goal: Monotone fun y => ∀ (x : β), x ∈ s → P x y

full_name: Antitone.ball
code: theorem Antitone.ball {P : β → α → Prop} {s : Set β} (hP : ∀ x ∈ s, Antitone (P x)) :
    Antitone fun y => ∀ x ∈ s, P x y 
goal: Antitone fun y => ∀ (x : β), x ∈ s → P x y

full_name: Monotone.exists
code: theorem Monotone.exists {P : β → α → Prop} (hP : ∀ x, Monotone (P x)) :
    Monotone fun y => ∃ x, P x y 
goal: Monotone fun y => ∃ x, P x y

full_name: Antitone.exists
code: theorem Antitone.exists {P : β → α → Prop} (hP : ∀ x, Antitone (P x)) :
    Antitone fun y => ∃ x, P x y 
goal: Antitone fun y => ∃ x, P x y

full_name: forall_ge_iff
code: theorem forall_ge_iff {P : α → Prop} {x₀ : α} (hP : Monotone P) :
    (∀ x ≥ x₀, P x) ↔ P x₀ 
goal: (∀ (x : α), x ≥ x₀ → P x) ↔ P x₀

full_name: forall_le_iff
code: theorem forall_le_iff {P : α → Prop} {x₀ : α} (hP : Antitone P) :
    (∀ x ≤ x₀, P x) ↔ P x₀ 
goal: (∀ (x : α), x ≤ x₀ → P x) ↔ P x₀

full_name: exists_ge_and_iff_exists
code: theorem exists_ge_and_iff_exists {P : α → Prop} {x₀ : α} (hP : Monotone P) :
    (∃ x, x₀ ≤ x ∧ P x) ↔ ∃ x, P x 
goal: (∃ x, x₀ ≤ x ∧ P x) ↔ ∃ x, P x

full_name: exists_le_and_iff_exists
code: theorem exists_le_and_iff_exists {P : α → Prop} {x₀ : α} (hP : Antitone P) :
    (∃ x, x ≤ x₀ ∧ P x) ↔ ∃ x, P x 
goal: (∃ x, x ≤ x₀ ∧ P x) ↔ ∃ x, P x

full_name: Pi.instBotForall
code: instance [∀ i, Bot (α' i)] : Bot (∀ i, α' i) 
goal: Bot ((i : ι) → α' i)

full_name: Pi.bot_apply
code: @[simp]
theorem bot_apply [∀ i, Bot (α' i)] (i : ι) : (⊥ : ∀ i, α' i) i = ⊥ 
goal: ⊥ i = ⊥

full_name: Pi.bot_def
code: theorem bot_def [∀ i, Bot (α' i)] : (⊥ : ∀ i, α' i) = fun _ => ⊥ 
goal: ⊥ = fun x => ⊥

full_name: Pi.instTopForall
code: instance [∀ i, Top (α' i)] : Top (∀ i, α' i) 
goal: Top ((i : ι) → α' i)

full_name: Pi.top_apply
code: @[simp]
theorem top_apply [∀ i, Top (α' i)] (i : ι) : (⊤ : ∀ i, α' i) i = ⊤ 
goal: ⊤ i = ⊤

full_name: Pi.top_def
code: theorem top_def [∀ i, Top (α' i)] : (⊤ : ∀ i, α' i) = fun _ => ⊤ 
goal: ⊤ = fun x => ⊤

full_name: Pi.instOrderTop
code: instance instOrderTop [∀ i, LE (α' i)] [∀ i, OrderTop (α' i)] : OrderTop (∀ i, α' i) 
goal: OrderTop ((i : ι) → α' i)

full_name: Pi.instOrderBot
code: instance instOrderBot [∀ i, LE (α' i)] [∀ i, OrderBot (α' i)] : OrderBot (∀ i, α' i) 
goal: OrderBot ((i : ι) → α' i)

full_name: Pi.instBoundedOrder
code: instance instBoundedOrder [∀ i, LE (α' i)] [∀ i, BoundedOrder (α' i)] :
    BoundedOrder (∀ i, α' i) 
goal: BoundedOrder ((i : ι) → α' i)

full_name: eq_bot_of_bot_eq_top
code: theorem eq_bot_of_bot_eq_top (hα : (⊥ : α) = ⊤) (x : α) : x = (⊥ : α) 
goal: x = ⊥

full_name: eq_top_of_bot_eq_top
code: theorem eq_top_of_bot_eq_top (hα : (⊥ : α) = ⊤) (x : α) : x = (⊤ : α) 
goal: x = ⊤

full_name: subsingleton_of_top_le_bot
code: theorem subsingleton_of_top_le_bot (h : (⊤ : α) ≤ (⊥ : α)) : Subsingleton α 
goal: Subsingleton α

full_name: subsingleton_of_bot_eq_top
code: theorem subsingleton_of_bot_eq_top (hα : (⊥ : α) = (⊤ : α)) : Subsingleton α 
goal: Subsingleton α

full_name: subsingleton_iff_bot_eq_top
code: theorem subsingleton_iff_bot_eq_top : (⊥ : α) = (⊤ : α) ↔ Subsingleton α 
goal: ⊥ = ⊤ ↔ Subsingleton α

full_name: OrderTop.lift
code: /-- Pullback an `OrderTop`. -/
abbrev OrderTop.lift [LE α] [Top α] [LE β] [OrderTop β] (f : α → β)
    (map_le : ∀ a b, f a ≤ f b → a ≤ b) (map_top : f ⊤ = ⊤) : OrderTop α 
goal: OrderTop α

full_name: OrderBot.lift
code: /-- Pullback an `OrderBot`. -/
abbrev OrderBot.lift [LE α] [Bot α] [LE β] [OrderBot β] (f : α → β)
    (map_le : ∀ a b, f a ≤ f b → a ≤ b) (map_bot : f ⊥ = ⊥) : OrderBot α 
goal: OrderBot α

full_name: BoundedOrder.lift
code: /-- Pullback a `BoundedOrder`. -/
abbrev BoundedOrder.lift [LE α] [Top α] [Bot α] [LE β] [BoundedOrder β] (f : α → β)
    (map_le : ∀ a b, f a ≤ f b → a ≤ b) (map_top : f ⊤ = ⊤) (map_bot : f ⊥ = ⊥) :
    BoundedOrder α 
goal: BoundedOrder α

full_name: Subtype.orderBot
code: /-- A subtype remains a `⊥`-order if the property holds at `⊥`. -/
protected abbrev orderBot [LE α] [OrderBot α] (hbot : p ⊥) : OrderBot { x : α // p x } 
goal: OrderBot { x // p x }

full_name: Subtype.orderTop
code: /-- A subtype remains a `⊤`-order if the property holds at `⊤`. -/
protected abbrev orderTop [LE α] [OrderTop α] (htop : p ⊤) : OrderTop { x : α // p x } 
goal: OrderTop { x // p x }

full_name: Subtype.boundedOrder
code: /-- A subtype remains a bounded order if the property holds at `⊥` and `⊤`. -/
protected abbrev boundedOrder [LE α] [BoundedOrder α] (hbot : p ⊥) (htop : p ⊤) :
    BoundedOrder (Subtype p) 
goal: BoundedOrder (Subtype p)

full_name: Subtype.mk_bot
code: @[simp]
theorem mk_bot [OrderBot α] [OrderBot (Subtype p)] (hbot : p ⊥) : mk ⊥ hbot = ⊥ 
goal: ⟨⊥, hbot⟩ = ⊥

full_name: Subtype.mk_top
code: @[simp]
theorem mk_top [OrderTop α] [OrderTop (Subtype p)] (htop : p ⊤) : mk ⊤ htop = ⊤ 
goal: ⟨⊤, htop⟩ = ⊤

full_name: Subtype.coe_bot
code: theorem coe_bot [OrderBot α] [OrderBot (Subtype p)] (hbot : p ⊥) : ((⊥ : Subtype p) : α) = ⊥ 
goal: ↑⊥ = ⊥

full_name: Subtype.coe_top
code: theorem coe_top [OrderTop α] [OrderTop (Subtype p)] (htop : p ⊤) : ((⊤ : Subtype p) : α) = ⊤ 
goal: ↑⊤ = ⊤

full_name: Subtype.coe_eq_bot_iff
code: @[simp]
theorem coe_eq_bot_iff [OrderBot α] [OrderBot (Subtype p)] (hbot : p ⊥) {x : { x // p x }} :
    (x : α) = ⊥ ↔ x = ⊥ 
goal: ↑x = ⊥ ↔ x = ⊥

full_name: Subtype.coe_eq_top_iff
code: @[simp]
theorem coe_eq_top_iff [OrderTop α] [OrderTop (Subtype p)] (htop : p ⊤) {x : { x // p x }} :
    (x : α) = ⊤ ↔ x = ⊤ 
goal: ↑x = ⊤ ↔ x = ⊤

full_name: Subtype.mk_eq_bot_iff
code: @[simp]
theorem mk_eq_bot_iff [OrderBot α] [OrderBot (Subtype p)] (hbot : p ⊥) {x : α} (hx : p x) :
    (⟨x, hx⟩ : Subtype p) = ⊥ ↔ x = ⊥ 
goal: ⟨x, hx⟩ = ⊥ ↔ x = ⊥

full_name: Subtype.mk_eq_top_iff
code: @[simp]
theorem mk_eq_top_iff [OrderTop α] [OrderTop (Subtype p)] (htop : p ⊤) {x : α} (hx : p x) :
    (⟨x, hx⟩ : Subtype p) = ⊤ ↔ x = ⊤ 
goal: ⟨x, hx⟩ = ⊤ ↔ x = ⊤

full_name: Prod.instTop
code: instance instTop [Top α] [Top β] : Top (α × β) 
goal: Top (α × β)

full_name: Prod.instBot
code: instance instBot [Bot α] [Bot β] : Bot (α × β) 
goal: Bot (α × β)

full_name: Prod.fst_top
code: theorem fst_top [Top α] [Top β] : (⊤ : α × β).fst = ⊤ 
goal: ⊤.1 = ⊤

full_name: Prod.snd_top
code: theorem snd_top [Top α] [Top β] : (⊤ : α × β).snd = ⊤ 
goal: ⊤.2 = ⊤

full_name: Prod.fst_bot
code: theorem fst_bot [Bot α] [Bot β] : (⊥ : α × β).fst = ⊥ 
goal: ⊥.1 = ⊥

full_name: Prod.snd_bot
code: theorem snd_bot [Bot α] [Bot β] : (⊥ : α × β).snd = ⊥ 
goal: ⊥.2 = ⊥

full_name: Prod.instOrderTop
code: instance instOrderTop [LE α] [LE β] [OrderTop α] [OrderTop β] : OrderTop (α × β) 
goal: OrderTop (α × β)

full_name: Prod.instOrderBot
code: instance instOrderBot [LE α] [LE β] [OrderBot α] [OrderBot β] : OrderBot (α × β) 
goal: OrderBot (α × β)

full_name: Prod.instBoundedOrder
code: instance instBoundedOrder [LE α] [LE β] [BoundedOrder α] [BoundedOrder β] :
    BoundedOrder (α × β) 
goal: BoundedOrder (α × β)

full_name: ULift.instTop
code: instance [Top α] : Top (ULift.{v} α) 
goal: Top (ULift.{v, u} α)

full_name: ULift.up_top
code: @[simp] theorem up_top [Top α] : up (⊤ : α) = ⊤ 
goal: { down := ⊤ } = ⊤

full_name: ULift.down_top
code: @[simp] theorem down_top [Top α] : down (⊤ : ULift α) = ⊤ 
goal: ⊤.down = ⊤

full_name: ULift.instBot
code: instance [Bot α] : Bot (ULift.{v} α) 
goal: Bot (ULift.{v, u} α)

full_name: ULift.up_bot
code: @[simp] theorem up_bot [Bot α] : up (⊥ : α) = ⊥ 
goal: { down := ⊥ } = ⊥

full_name: ULift.down_bot
code: @[simp] theorem down_bot [Bot α] : down (⊥ : ULift α) = ⊥ 
goal: ⊥.down = ⊥

full_name: ULift.instOrderBot
code: instance [LE α] [OrderBot α] : OrderBot (ULift.{v} α) 
goal: OrderBot (ULift.{v, u} α)

full_name: ULift.instOrderTop
code: instance [LE α] [OrderTop α] : OrderTop (ULift.{v} α) 
goal: OrderTop (ULift.{v, u} α)

full_name: ULift.instBoundedOrder
code: instance [LE α] [BoundedOrder α] : BoundedOrder (ULift.{v} α) 
goal: BoundedOrder (ULift.{v, u} α)

full_name: min_bot_left
code: theorem min_bot_left [OrderBot α] (a : α) : min ⊥ a = ⊥ 
goal: min ⊥ a = ⊥

full_name: max_top_left
code: theorem max_top_left [OrderTop α] (a : α) : max ⊤ a = ⊤ 
goal: max ⊤ a = ⊤

full_name: min_top_left
code: theorem min_top_left [OrderTop α] (a : α) : min ⊤ a = a 
goal: min ⊤ a = a

full_name: max_bot_left
code: theorem max_bot_left [OrderBot α] (a : α) : max ⊥ a = a 
goal: max ⊥ a = a

full_name: min_top_right
code: theorem min_top_right [OrderTop α] (a : α) : min a ⊤ = a 
goal: min a ⊤ = a

full_name: max_bot_right
code: theorem max_bot_right [OrderBot α] (a : α) : max a ⊥ = a 
goal: max a ⊥ = a

full_name: min_bot_right
code: theorem min_bot_right [OrderBot α] (a : α) : min a ⊥ = ⊥ 
goal: min a ⊥ = ⊥

full_name: max_top_right
code: theorem max_top_right [OrderTop α] (a : α) : max a ⊤ = ⊤ 
goal: max a ⊤ = ⊤

full_name: min_eq_bot
code: @[simp]
theorem min_eq_bot [OrderBot α] {a b : α} : min a b = ⊥ ↔ a = ⊥ ∨ b = ⊥ 
goal: min a b = ⊥ ↔ a = ⊥ ∨ b = ⊥

full_name: max_eq_top
code: @[simp]
theorem max_eq_top [OrderTop α] {a b : α} : max a b = ⊤ ↔ a = ⊤ ∨ b = ⊤ 
goal: max a b = ⊤ ↔ a = ⊤ ∨ b = ⊤

full_name: max_eq_bot
code: @[simp]
theorem max_eq_bot [OrderBot α] {a b : α} : max a b = ⊥ ↔ a = ⊥ ∧ b = ⊥ 
goal: max a b = ⊥ ↔ a = ⊥ ∧ b = ⊥

full_name: min_eq_top
code: @[simp]
theorem min_eq_top [OrderTop α] {a b : α} : min a b = ⊤ ↔ a = ⊤ ∧ b = ⊤ 
goal: min a b = ⊤ ↔ a = ⊤ ∧ b = ⊤

full_name: bot_ne_top
code: @[simp]
theorem bot_ne_top : (⊥ : α) ≠ ⊤ 
goal: ⊥ ≠ ⊤

full_name: top_ne_bot
code: @[simp]
theorem top_ne_bot : (⊤ : α) ≠ ⊥ 
goal: ⊤ ≠ ⊥

full_name: bot_lt_top
code: @[simp]
theorem bot_lt_top : (⊥ : α) < ⊤ 
goal: ⊥ < ⊤

full_name: Bool.instBoundedOrder
code: instance Bool.instBoundedOrder : BoundedOrder Bool 
goal: BoundedOrder Bool

full_name: top_eq_true
code: @[simp]
theorem top_eq_true : ⊤ = true 
goal: ⊤ = true

full_name: bot_eq_false
code: @[simp]
theorem bot_eq_false : ⊥ = false 
goal: ⊥ = false