File: Mathlib/Order/Bounds/Basic.lean

full_name: upperBounds
code: /-- The set of upper bounds of a set. -/
def upperBounds (s : Set α) : Set α 
goal: Set α

full_name: lowerBounds
code: /-- The set of lower bounds of a set. -/
def lowerBounds (s : Set α) : Set α 
goal: Set α

full_name: BddAbove
code: /-- A set is bounded above if there exists an upper bound. -/
def BddAbove (s : Set α) 
goal: Prop

full_name: BddBelow
code: /-- A set is bounded below if there exists a lower bound. -/
def BddBelow (s : Set α) 
goal: Prop

full_name: IsLeast
code: /-- `a` is a least element of a set `s`; for a partial order, it is unique if exists. -/
def IsLeast (s : Set α) (a : α) : Prop 
goal: Prop

full_name: IsGreatest
code: /-- `a` is a greatest element of a set `s`; for a partial order, it is unique if exists. -/
def IsGreatest (s : Set α) (a : α) : Prop 
goal: Prop

full_name: IsLUB
code: /-- `a` is a least upper bound of a set `s`; for a partial order, it is unique if exists. -/
def IsLUB (s : Set α) : α → Prop 
goal: α → Prop

full_name: IsGLB
code: /-- `a` is a greatest lower bound of a set `s`; for a partial order, it is unique if exists. -/
def IsGLB (s : Set α) : α → Prop 
goal: α → Prop

full_name: mem_upperBounds
code: theorem mem_upperBounds : a ∈ upperBounds s ↔ ∀ x ∈ s, x ≤ a 
goal: a ∈ upperBounds s ↔ ∀ x ∈ s, x ≤ a

full_name: mem_lowerBounds
code: theorem mem_lowerBounds : a ∈ lowerBounds s ↔ ∀ x ∈ s, a ≤ x 
goal: a ∈ lowerBounds s ↔ ∀ x ∈ s, a ≤ x

full_name: mem_upperBounds_iff_subset_Iic
code: lemma mem_upperBounds_iff_subset_Iic : a ∈ upperBounds s ↔ s ⊆ Iic a 
goal: a ∈ upperBounds s ↔ s ⊆ Set.Iic a

full_name: mem_lowerBounds_iff_subset_Ici
code: lemma mem_lowerBounds_iff_subset_Ici : a ∈ lowerBounds s ↔ s ⊆ Ici a 
goal: a ∈ lowerBounds s ↔ s ⊆ Set.Ici a

full_name: bddAbove_def
code: theorem bddAbove_def : BddAbove s ↔ ∃ x, ∀ y ∈ s, y ≤ x 
goal: BddAbove s ↔ ∃ x, ∀ y ∈ s, y ≤ x

full_name: bddBelow_def
code: theorem bddBelow_def : BddBelow s ↔ ∃ x, ∀ y ∈ s, x ≤ y 
goal: BddBelow s ↔ ∃ x, ∀ y ∈ s, x ≤ y

full_name: bot_mem_lowerBounds
code: theorem bot_mem_lowerBounds [OrderBot α] (s : Set α) : ⊥ ∈ lowerBounds s 
goal: ⊥ ∈ lowerBounds s

full_name: top_mem_upperBounds
code: theorem top_mem_upperBounds [OrderTop α] (s : Set α) : ⊤ ∈ upperBounds s 
goal: ⊤ ∈ upperBounds s

full_name: isLeast_bot_iff
code: @[simp]
theorem isLeast_bot_iff [OrderBot α] : IsLeast s ⊥ ↔ ⊥ ∈ s 
goal: IsLeast s ⊥ ↔ ⊥ ∈ s

full_name: isGreatest_top_iff
code: @[simp]
theorem isGreatest_top_iff [OrderTop α] : IsGreatest s ⊤ ↔ ⊤ ∈ s 
goal: IsGreatest s ⊤ ↔ ⊤ ∈ s

full_name: not_bddAbove_iff'
code: /-- A set `s` is not bounded above if and only if for each `x` there exists `y ∈ s` such that `x`
is not greater than or equal to `y`. This version only assumes `Preorder` structure and uses
`¬(y ≤ x)`. A version for linear orders is called `not_bddAbove_iff`. -/
theorem not_bddAbove_iff' : ¬BddAbove s ↔ ∀ x, ∃ y ∈ s, ¬y ≤ x 
goal: ¬BddAbove s ↔ ∀ (x : α), ∃ y ∈ s, ¬y ≤ x

full_name: not_bddBelow_iff'
code: /-- A set `s` is not bounded below if and only if for each `x` there exists `y ∈ s` such that `x`
is not less than or equal to `y`. This version only assumes `Preorder` structure and uses
`¬(x ≤ y)`. A version for linear orders is called `not_bddBelow_iff`. -/
theorem not_bddBelow_iff' : ¬BddBelow s ↔ ∀ x, ∃ y ∈ s, ¬x ≤ y 
goal: ¬BddBelow s ↔ ∀ (x : α), ∃ y ∈ s, ¬x ≤ y

full_name: not_bddAbove_iff
code: /-- A set `s` is not bounded above if and only if for each `x` there exists `y ∈ s` that is greater
than `x`. A version for preorders is called `not_bddAbove_iff'`. -/
theorem not_bddAbove_iff {α : Type*} [LinearOrder α] {s : Set α} :
    ¬BddAbove s ↔ ∀ x, ∃ y ∈ s, x < y 
goal: ¬BddAbove s ↔ ∀ (x : α), ∃ y ∈ s, x < y

full_name: not_bddBelow_iff
code: /-- A set `s` is not bounded below if and only if for each `x` there exists `y ∈ s` that is less
than `x`. A version for preorders is called `not_bddBelow_iff'`. -/
theorem not_bddBelow_iff {α : Type*} [LinearOrder α] {s : Set α} :
    ¬BddBelow s ↔ ∀ x, ∃ y ∈ s, y < x 
goal: ¬BddBelow s ↔ ∀ (x : α), ∃ y ∈ s, y < x

full_name: bddBelow_preimage_ofDual
code: @[simp] lemma bddBelow_preimage_ofDual {s : Set α} : BddBelow (ofDual ⁻¹' s) ↔ BddAbove s 
goal: BddBelow (⇑OrderDual.ofDual ⁻¹' s) ↔ BddAbove s

full_name: bddAbove_preimage_ofDual
code: @[simp] lemma bddAbove_preimage_ofDual {s : Set α} : BddAbove (ofDual ⁻¹' s) ↔ BddBelow s 
goal: BddAbove (⇑OrderDual.ofDual ⁻¹' s) ↔ BddBelow s

full_name: bddBelow_preimage_toDual
code: @[simp] lemma bddBelow_preimage_toDual {s : Set αᵒᵈ} :
    BddBelow (toDual ⁻¹' s) ↔ BddAbove s 
goal: BddBelow (⇑OrderDual.toDual ⁻¹' s) ↔ BddAbove s

full_name: bddAbove_preimage_toDual
code: @[simp] lemma bddAbove_preimage_toDual {s : Set αᵒᵈ} :
    BddAbove (toDual ⁻¹' s) ↔ BddBelow s 
goal: BddAbove (⇑OrderDual.toDual ⁻¹' s) ↔ BddBelow s

full_name: BddAbove.dual
code: theorem BddAbove.dual (h : BddAbove s) : BddBelow (ofDual ⁻¹' s) 
goal: BddBelow (⇑OrderDual.ofDual ⁻¹' s)

full_name: BddBelow.dual
code: theorem BddBelow.dual (h : BddBelow s) : BddAbove (ofDual ⁻¹' s) 
goal: BddAbove (⇑OrderDual.ofDual ⁻¹' s)

full_name: IsLeast.dual
code: theorem IsLeast.dual (h : IsLeast s a) : IsGreatest (ofDual ⁻¹' s) (toDual a) 
goal: IsGreatest (⇑OrderDual.ofDual ⁻¹' s) (OrderDual.toDual a)

full_name: IsGreatest.dual
code: theorem IsGreatest.dual (h : IsGreatest s a) : IsLeast (ofDual ⁻¹' s) (toDual a) 
goal: IsLeast (⇑OrderDual.ofDual ⁻¹' s) (OrderDual.toDual a)

full_name: IsLUB.dual
code: theorem IsLUB.dual (h : IsLUB s a) : IsGLB (ofDual ⁻¹' s) (toDual a) 
goal: IsGLB (⇑OrderDual.ofDual ⁻¹' s) (OrderDual.toDual a)

full_name: IsGLB.dual
code: theorem IsGLB.dual (h : IsGLB s a) : IsLUB (ofDual ⁻¹' s) (toDual a) 
goal: IsLUB (⇑OrderDual.ofDual ⁻¹' s) (OrderDual.toDual a)

full_name: IsLeast.orderBot
code: /-- If `a` is the least element of a set `s`, then subtype `s` is an order with bottom element. -/
abbrev IsLeast.orderBot (h : IsLeast s a) :
    OrderBot s 
goal: OrderBot ↑s

full_name: IsGreatest.orderTop
code: /-- If `a` is the greatest element of a set `s`, then subtype `s` is an order with top element. -/
abbrev IsGreatest.orderTop (h : IsGreatest s a) :
    OrderTop s 
goal: OrderTop ↑s

full_name: upperBounds_mono_set
code: theorem upperBounds_mono_set ⦃s t : Set α⦄ (hst : s ⊆ t) : upperBounds t ⊆ upperBounds s 
goal: upperBounds t ⊆ upperBounds s

full_name: lowerBounds_mono_set
code: theorem lowerBounds_mono_set ⦃s t : Set α⦄ (hst : s ⊆ t) : lowerBounds t ⊆ lowerBounds s 
goal: lowerBounds t ⊆ lowerBounds s

full_name: upperBounds_mono_mem
code: theorem upperBounds_mono_mem ⦃a b⦄ (hab : a ≤ b) : a ∈ upperBounds s → b ∈ upperBounds s 
goal: a ∈ upperBounds s → b ∈ upperBounds s

full_name: lowerBounds_mono_mem
code: theorem lowerBounds_mono_mem ⦃a b⦄ (hab : a ≤ b) : b ∈ lowerBounds s → a ∈ lowerBounds s 
goal: b ∈ lowerBounds s → a ∈ lowerBounds s

full_name: upperBounds_mono
code: theorem upperBounds_mono ⦃s t : Set α⦄ (hst : s ⊆ t) ⦃a b⦄ (hab : a ≤ b) :
    a ∈ upperBounds t → b ∈ upperBounds s 
goal: a ∈ upperBounds t → b ∈ upperBounds s

full_name: lowerBounds_mono
code: theorem lowerBounds_mono ⦃s t : Set α⦄ (hst : s ⊆ t) ⦃a b⦄ (hab : a ≤ b) :
    b ∈ lowerBounds t → a ∈ lowerBounds s 
goal: b ∈ lowerBounds t → a ∈ lowerBounds s

full_name: BddAbove.mono
code: /-- If `s ⊆ t` and `t` is bounded above, then so is `s`. -/
theorem BddAbove.mono ⦃s t : Set α⦄ (h : s ⊆ t) : BddAbove t → BddAbove s 
goal: BddAbove t → BddAbove s

full_name: BddBelow.mono
code: /-- If `s ⊆ t` and `t` is bounded below, then so is `s`. -/
theorem BddBelow.mono ⦃s t : Set α⦄ (h : s ⊆ t) : BddBelow t → BddBelow s 
goal: BddBelow t → BddBelow s

full_name: IsLUB.of_subset_of_superset
code: /-- If `a` is a least upper bound for sets `s` and `p`, then it is a least upper bound for any
set `t`, `s ⊆ t ⊆ p`. -/
theorem IsLUB.of_subset_of_superset {s t p : Set α} (hs : IsLUB s a) (hp : IsLUB p a) (hst : s ⊆ t)
    (htp : t ⊆ p) : IsLUB t a 
goal: IsLUB t a

full_name: IsGLB.of_subset_of_superset
code: /-- If `a` is a greatest lower bound for sets `s` and `p`, then it is a greater lower bound for any
set `t`, `s ⊆ t ⊆ p`. -/
theorem IsGLB.of_subset_of_superset {s t p : Set α} (hs : IsGLB s a) (hp : IsGLB p a) (hst : s ⊆ t)
    (htp : t ⊆ p) : IsGLB t a 
goal: IsGLB t a

full_name: IsLeast.mono
code: theorem IsLeast.mono (ha : IsLeast s a) (hb : IsLeast t b) (hst : s ⊆ t) : b ≤ a 
goal: b ≤ a

full_name: IsGreatest.mono
code: theorem IsGreatest.mono (ha : IsGreatest s a) (hb : IsGreatest t b) (hst : s ⊆ t) : a ≤ b 
goal: a ≤ b

full_name: IsLUB.mono
code: theorem IsLUB.mono (ha : IsLUB s a) (hb : IsLUB t b) (hst : s ⊆ t) : a ≤ b 
goal: a ≤ b

full_name: IsGLB.mono
code: theorem IsGLB.mono (ha : IsGLB s a) (hb : IsGLB t b) (hst : s ⊆ t) : b ≤ a 
goal: b ≤ a

full_name: subset_lowerBounds_upperBounds
code: theorem subset_lowerBounds_upperBounds (s : Set α) : s ⊆ lowerBounds (upperBounds s) 
goal: s ⊆ lowerBounds (upperBounds s)

full_name: subset_upperBounds_lowerBounds
code: theorem subset_upperBounds_lowerBounds (s : Set α) : s ⊆ upperBounds (lowerBounds s) 
goal: s ⊆ upperBounds (lowerBounds s)

full_name: Set.Nonempty.bddAbove_lowerBounds
code: theorem Set.Nonempty.bddAbove_lowerBounds (hs : s.Nonempty) : BddAbove (lowerBounds s) 
goal: BddAbove (lowerBounds s)

full_name: Set.Nonempty.bddBelow_upperBounds
code: theorem Set.Nonempty.bddBelow_upperBounds (hs : s.Nonempty) : BddBelow (upperBounds s) 
goal: BddBelow (upperBounds s)

full_name: IsLeast.isGLB
code: theorem IsLeast.isGLB (h : IsLeast s a) : IsGLB s a 
goal: IsGLB s a

full_name: IsGreatest.isLUB
code: theorem IsGreatest.isLUB (h : IsGreatest s a) : IsLUB s a 
goal: IsLUB s a

full_name: IsLUB.upperBounds_eq
code: theorem IsLUB.upperBounds_eq (h : IsLUB s a) : upperBounds s = Ici a 
goal: upperBounds s = Set.Ici a

full_name: IsGLB.lowerBounds_eq
code: theorem IsGLB.lowerBounds_eq (h : IsGLB s a) : lowerBounds s = Iic a 
goal: lowerBounds s = Set.Iic a

full_name: IsLeast.lowerBounds_eq
code: theorem IsLeast.lowerBounds_eq (h : IsLeast s a) : lowerBounds s = Iic a 
goal: lowerBounds s = Set.Iic a

full_name: IsGreatest.upperBounds_eq
code: theorem IsGreatest.upperBounds_eq (h : IsGreatest s a) : upperBounds s = Ici a 
goal: upperBounds s = Set.Ici a

full_name: IsGreatest.lt_iff
code: theorem IsGreatest.lt_iff (h : IsGreatest s a) : a < b ↔ ∀ x ∈ s, x < b 
goal: a < b ↔ ∀ x ∈ s, x < b

full_name: IsLeast.lt_iff
code: theorem IsLeast.lt_iff (h : IsLeast s a) : b < a ↔ ∀ x ∈ s, b < x 
goal: b < a ↔ ∀ x ∈ s, b < x

full_name: isLUB_le_iff
code: theorem isLUB_le_iff (h : IsLUB s a) : a ≤ b ↔ b ∈ upperBounds s 
goal: a ≤ b ↔ b ∈ upperBounds s

full_name: le_isGLB_iff
code: theorem le_isGLB_iff (h : IsGLB s a) : b ≤ a ↔ b ∈ lowerBounds s 
goal: b ≤ a ↔ b ∈ lowerBounds s

full_name: isLUB_iff_le_iff
code: theorem isLUB_iff_le_iff : IsLUB s a ↔ ∀ b, a ≤ b ↔ b ∈ upperBounds s 
goal: IsLUB s a ↔ ∀ (b : α), a ≤ b ↔ b ∈ upperBounds s

full_name: isGLB_iff_le_iff
code: theorem isGLB_iff_le_iff : IsGLB s a ↔ ∀ b, b ≤ a ↔ b ∈ lowerBounds s 
goal: IsGLB s a ↔ ∀ (b : α), b ≤ a ↔ b ∈ lowerBounds s

full_name: IsLUB.bddAbove
code: /-- If `s` has a least upper bound, then it is bounded above. -/
theorem IsLUB.bddAbove (h : IsLUB s a) : BddAbove s 
goal: BddAbove s

full_name: IsGLB.bddBelow
code: /-- If `s` has a greatest lower bound, then it is bounded below. -/
theorem IsGLB.bddBelow (h : IsGLB s a) : BddBelow s 
goal: BddBelow s

full_name: IsGreatest.bddAbove
code: /-- If `s` has a greatest element, then it is bounded above. -/
theorem IsGreatest.bddAbove (h : IsGreatest s a) : BddAbove s 
goal: BddAbove s

full_name: IsLeast.bddBelow
code: /-- If `s` has a least element, then it is bounded below. -/
theorem IsLeast.bddBelow (h : IsLeast s a) : BddBelow s 
goal: BddBelow s

full_name: IsLeast.nonempty
code: theorem IsLeast.nonempty (h : IsLeast s a) : s.Nonempty 
goal: s.Nonempty

full_name: IsGreatest.nonempty
code: theorem IsGreatest.nonempty (h : IsGreatest s a) : s.Nonempty 
goal: s.Nonempty

full_name: upperBounds_union
code: @[simp]
theorem upperBounds_union : upperBounds (s ∪ t) = upperBounds s ∩ upperBounds t 
goal: upperBounds (s ∪ t) = upperBounds s ∩ upperBounds t

full_name: lowerBounds_union
code: @[simp]
theorem lowerBounds_union : lowerBounds (s ∪ t) = lowerBounds s ∩ lowerBounds t 
goal: lowerBounds (s ∪ t) = lowerBounds s ∩ lowerBounds t

full_name: union_upperBounds_subset_upperBounds_inter
code: theorem union_upperBounds_subset_upperBounds_inter :
    upperBounds s ∪ upperBounds t ⊆ upperBounds (s ∩ t) 
goal: upperBounds s ∪ upperBounds t ⊆ upperBounds (s ∩ t)

full_name: union_lowerBounds_subset_lowerBounds_inter
code: theorem union_lowerBounds_subset_lowerBounds_inter :
    lowerBounds s ∪ lowerBounds t ⊆ lowerBounds (s ∩ t) 
goal: lowerBounds s ∪ lowerBounds t ⊆ lowerBounds (s ∩ t)

full_name: isLeast_union_iff
code: theorem isLeast_union_iff {a : α} {s t : Set α} :
    IsLeast (s ∪ t) a ↔ IsLeast s a ∧ a ∈ lowerBounds t ∨ a ∈ lowerBounds s ∧ IsLeast t a 
goal: IsLeast (s ∪ t) a ↔ IsLeast s a ∧ a ∈ lowerBounds t ∨ a ∈ lowerBounds s ∧ IsLeast t a

full_name: isGreatest_union_iff
code: theorem isGreatest_union_iff :
    IsGreatest (s ∪ t) a ↔
      IsGreatest s a ∧ a ∈ upperBounds t ∨ a ∈ upperBounds s ∧ IsGreatest t a 
goal: IsGreatest (s ∪ t) a ↔ IsGreatest s a ∧ a ∈ upperBounds t ∨ a ∈ upperBounds s ∧ IsGreatest t a

full_name: BddAbove.inter_of_left
code: /-- If `s` is bounded, then so is `s ∩ t` -/
theorem BddAbove.inter_of_left (h : BddAbove s) : BddAbove (s ∩ t) 
goal: BddAbove (s ∩ t)

full_name: BddAbove.inter_of_right
code: /-- If `t` is bounded, then so is `s ∩ t` -/
theorem BddAbove.inter_of_right (h : BddAbove t) : BddAbove (s ∩ t) 
goal: BddAbove (s ∩ t)

full_name: BddBelow.inter_of_left
code: /-- If `s` is bounded, then so is `s ∩ t` -/
theorem BddBelow.inter_of_left (h : BddBelow s) : BddBelow (s ∩ t) 
goal: BddBelow (s ∩ t)

full_name: BddBelow.inter_of_right
code: /-- If `t` is bounded, then so is `s ∩ t` -/
theorem BddBelow.inter_of_right (h : BddBelow t) : BddBelow (s ∩ t) 
goal: BddBelow (s ∩ t)

full_name: BddAbove.union
code: /-- In a directed order, the union of bounded above sets is bounded above. -/
theorem BddAbove.union [IsDirected α (· ≤ ·)] {s t : Set α} :
    BddAbove s → BddAbove t → BddAbove (s ∪ t) 
goal: BddAbove s → BddAbove t → BddAbove (s ∪ t)

full_name: bddAbove_union
code: /-- In a directed order, the union of two sets is bounded above if and only if both sets are. -/
theorem bddAbove_union [IsDirected α (· ≤ ·)] {s t : Set α} :
    BddAbove (s ∪ t) ↔ BddAbove s ∧ BddAbove t 
goal: BddAbove (s ∪ t) ↔ BddAbove s ∧ BddAbove t

full_name: BddBelow.union
code: /-- In a codirected order, the union of bounded below sets is bounded below. -/
theorem BddBelow.union [IsDirected α (· ≥ ·)] {s t : Set α} :
    BddBelow s → BddBelow t → BddBelow (s ∪ t) 
goal: BddBelow s → BddBelow t → BddBelow (s ∪ t)

full_name: bddBelow_union
code: /-- In a codirected order, the union of two sets is bounded below if and only if both sets are. -/
theorem bddBelow_union [IsDirected α (· ≥ ·)] {s t : Set α} :
    BddBelow (s ∪ t) ↔ BddBelow s ∧ BddBelow t 
goal: BddBelow (s ∪ t) ↔ BddBelow s ∧ BddBelow t

full_name: IsLUB.union
code: /-- If `a` is the least upper bound of `s` and `b` is the least upper bound of `t`,
then `a ⊔ b` is the least upper bound of `s ∪ t`. -/
theorem IsLUB.union [SemilatticeSup γ] {a b : γ} {s t : Set γ} (hs : IsLUB s a) (ht : IsLUB t b) :
    IsLUB (s ∪ t) (a ⊔ b) 
goal: IsLUB (s ∪ t) (a ⊔ b)

full_name: IsGLB.union
code: /-- If `a` is the greatest lower bound of `s` and `b` is the greatest lower bound of `t`,
then `a ⊓ b` is the greatest lower bound of `s ∪ t`. -/
theorem IsGLB.union [SemilatticeInf γ] {a₁ a₂ : γ} {s t : Set γ} (hs : IsGLB s a₁)
    (ht : IsGLB t a₂) : IsGLB (s ∪ t) (a₁ ⊓ a₂) 
goal: IsGLB (s ∪ t) (a₁ ⊓ a₂)

full_name: IsLeast.union
code: /-- If `a` is the least element of `s` and `b` is the least element of `t`,
then `min a b` is the least element of `s ∪ t`. -/
theorem IsLeast.union [LinearOrder γ] {a b : γ} {s t : Set γ} (ha : IsLeast s a)
    (hb : IsLeast t b) : IsLeast (s ∪ t) (min a b) 
goal: IsLeast (s ∪ t) (min a b)

full_name: IsGreatest.union
code: /-- If `a` is the greatest element of `s` and `b` is the greatest element of `t`,
then `max a b` is the greatest element of `s ∪ t`. -/
theorem IsGreatest.union [LinearOrder γ] {a b : γ} {s t : Set γ} (ha : IsGreatest s a)
    (hb : IsGreatest t b) : IsGreatest (s ∪ t) (max a b) 
goal: IsGreatest (s ∪ t) (max a b)

full_name: IsLUB.inter_Ici_of_mem
code: theorem IsLUB.inter_Ici_of_mem [LinearOrder γ] {s : Set γ} {a b : γ} (ha : IsLUB s a) (hb : b ∈ s) :
    IsLUB (s ∩ Ici b) a 
goal: IsLUB (s ∩ Set.Ici b) a

full_name: IsGLB.inter_Iic_of_mem
code: theorem IsGLB.inter_Iic_of_mem [LinearOrder γ] {s : Set γ} {a b : γ} (ha : IsGLB s a) (hb : b ∈ s) :
    IsGLB (s ∩ Iic b) a 
goal: IsGLB (s ∩ Set.Iic b) a

full_name: bddAbove_iff_exists_ge
code: theorem bddAbove_iff_exists_ge [SemilatticeSup γ] {s : Set γ} (x₀ : γ) :
    BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x 
goal: BddAbove s ↔ ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x

full_name: bddBelow_iff_exists_le
code: theorem bddBelow_iff_exists_le [SemilatticeInf γ] {s : Set γ} (x₀ : γ) :
    BddBelow s ↔ ∃ x, x ≤ x₀ ∧ ∀ y ∈ s, x ≤ y 
goal: BddBelow s ↔ ∃ x ≤ x₀, ∀ y ∈ s, x ≤ y

full_name: BddAbove.exists_ge
code: theorem BddAbove.exists_ge [SemilatticeSup γ] {s : Set γ} (hs : BddAbove s) (x₀ : γ) :
    ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x 
goal: ∃ x, x₀ ≤ x ∧ ∀ y ∈ s, y ≤ x

full_name: BddBelow.exists_le
code: theorem BddBelow.exists_le [SemilatticeInf γ] {s : Set γ} (hs : BddBelow s) (x₀ : γ) :
    ∃ x, x ≤ x₀ ∧ ∀ y ∈ s, x ≤ y 
goal: ∃ x ≤ x₀, ∀ y ∈ s, x ≤ y

full_name: isLeast_Ici
code: theorem isLeast_Ici : IsLeast (Ici a) a 
goal: IsLeast (Set.Ici a) a

full_name: isGreatest_Iic
code: theorem isGreatest_Iic : IsGreatest (Iic a) a 
goal: IsGreatest (Set.Iic a) a

full_name: isLUB_Iic
code: theorem isLUB_Iic : IsLUB (Iic a) a 
goal: IsLUB (Set.Iic a) a

full_name: isGLB_Ici
code: theorem isGLB_Ici : IsGLB (Ici a) a 
goal: IsGLB (Set.Ici a) a

full_name: upperBounds_Iic
code: theorem upperBounds_Iic : upperBounds (Iic a) = Ici a 
goal: upperBounds (Set.Iic a) = Set.Ici a

full_name: lowerBounds_Ici
code: theorem lowerBounds_Ici : lowerBounds (Ici a) = Iic a 
goal: lowerBounds (Set.Ici a) = Set.Iic a

full_name: bddAbove_Iic
code: theorem bddAbove_Iic : BddAbove (Iic a) 
goal: BddAbove (Set.Iic a)

full_name: bddBelow_Ici
code: theorem bddBelow_Ici : BddBelow (Ici a) 
goal: BddBelow (Set.Ici a)

full_name: bddAbove_Iio
code: theorem bddAbove_Iio : BddAbove (Iio a) 
goal: BddAbove (Set.Iio a)

full_name: bddBelow_Ioi
code: theorem bddBelow_Ioi : BddBelow (Ioi a) 
goal: BddBelow (Set.Ioi a)

full_name: lub_Iio_le
code: theorem lub_Iio_le (a : α) (hb : IsLUB (Iio a) b) : b ≤ a 
goal: b ≤ a

full_name: le_glb_Ioi
code: theorem le_glb_Ioi (a : α) (hb : IsGLB (Ioi a) b) : a ≤ b 
goal: a ≤ b

full_name: lub_Iio_eq_self_or_Iio_eq_Iic
code: theorem lub_Iio_eq_self_or_Iio_eq_Iic [PartialOrder γ] {j : γ} (i : γ) (hj : IsLUB (Iio i) j) :
    j = i ∨ Iio i = Iic j 
goal: j = i ∨ Set.Iio i = Set.Iic j

full_name: glb_Ioi_eq_self_or_Ioi_eq_Ici
code: theorem glb_Ioi_eq_self_or_Ioi_eq_Ici [PartialOrder γ] {j : γ} (i : γ) (hj : IsGLB (Ioi i) j) :
    j = i ∨ Ioi i = Ici j 
goal: j = i ∨ Set.Ioi i = Set.Ici j

full_name: exists_lub_Iio
code: theorem exists_lub_Iio (i : γ) : ∃ j, IsLUB (Iio i) j 
goal: ∃ j, IsLUB (Set.Iio i) j

full_name: exists_glb_Ioi
code: theorem exists_glb_Ioi (i : γ) : ∃ j, IsGLB (Ioi i) j 
goal: ∃ j, IsGLB (Set.Ioi i) j

full_name: isLUB_Iio
code: theorem isLUB_Iio {a : γ} : IsLUB (Iio a) a 
goal: IsLUB (Set.Iio a) a

full_name: isGLB_Ioi
code: theorem isGLB_Ioi {a : γ} : IsGLB (Ioi a) a 
goal: IsGLB (Set.Ioi a) a

full_name: upperBounds_Iio
code: theorem upperBounds_Iio {a : γ} : upperBounds (Iio a) = Ici a 
goal: upperBounds (Set.Iio a) = Set.Ici a

full_name: lowerBounds_Ioi
code: theorem lowerBounds_Ioi {a : γ} : lowerBounds (Ioi a) = Iic a 
goal: lowerBounds (Set.Ioi a) = Set.Iic a

full_name: isGreatest_singleton
code: @[simp] theorem isGreatest_singleton : IsGreatest {a} a 
goal: IsGreatest {a} a

full_name: isLeast_singleton
code: @[simp] theorem isLeast_singleton : IsLeast {a} a 
goal: IsLeast {a} a

full_name: isLUB_singleton
code: @[simp] theorem isLUB_singleton : IsLUB {a} a 
goal: IsLUB {a} a

full_name: isGLB_singleton
code: @[simp] theorem isGLB_singleton : IsGLB {a} a 
goal: IsGLB {a} a

full_name: bddAbove_singleton
code: @[simp] lemma bddAbove_singleton : BddAbove ({a} : Set α) 
goal: BddAbove {a}

full_name: bddBelow_singleton
code: @[simp] lemma bddBelow_singleton : BddBelow ({a} : Set α) 
goal: BddBelow {a}

full_name: upperBounds_singleton
code: @[simp]
theorem upperBounds_singleton : upperBounds {a} = Ici a 
goal: upperBounds {a} = Set.Ici a

full_name: lowerBounds_singleton
code: @[simp]
theorem lowerBounds_singleton : lowerBounds {a} = Iic a 
goal: lowerBounds {a} = Set.Iic a

full_name: bddAbove_Icc
code: theorem bddAbove_Icc : BddAbove (Icc a b) 
goal: BddAbove (Set.Icc a b)

full_name: bddBelow_Icc
code: theorem bddBelow_Icc : BddBelow (Icc a b) 
goal: BddBelow (Set.Icc a b)

full_name: bddAbove_Ico
code: theorem bddAbove_Ico : BddAbove (Ico a b) 
goal: BddAbove (Set.Ico a b)

full_name: bddBelow_Ico
code: theorem bddBelow_Ico : BddBelow (Ico a b) 
goal: BddBelow (Set.Ico a b)

full_name: bddAbove_Ioc
code: theorem bddAbove_Ioc : BddAbove (Ioc a b) 
goal: BddAbove (Set.Ioc a b)

full_name: bddBelow_Ioc
code: theorem bddBelow_Ioc : BddBelow (Ioc a b) 
goal: BddBelow (Set.Ioc a b)

full_name: bddAbove_Ioo
code: theorem bddAbove_Ioo : BddAbove (Ioo a b) 
goal: BddAbove (Set.Ioo a b)

full_name: bddBelow_Ioo
code: theorem bddBelow_Ioo : BddBelow (Ioo a b) 
goal: BddBelow (Set.Ioo a b)

full_name: isGreatest_Icc
code: theorem isGreatest_Icc (h : a ≤ b) : IsGreatest (Icc a b) b 
goal: IsGreatest (Set.Icc a b) b

full_name: isLUB_Icc
code: theorem isLUB_Icc (h : a ≤ b) : IsLUB (Icc a b) b 
goal: IsLUB (Set.Icc a b) b

full_name: upperBounds_Icc
code: theorem upperBounds_Icc (h : a ≤ b) : upperBounds (Icc a b) = Ici b 
goal: upperBounds (Set.Icc a b) = Set.Ici b

full_name: isLeast_Icc
code: theorem isLeast_Icc (h : a ≤ b) : IsLeast (Icc a b) a 
goal: IsLeast (Set.Icc a b) a

full_name: isGLB_Icc
code: theorem isGLB_Icc (h : a ≤ b) : IsGLB (Icc a b) a 
goal: IsGLB (Set.Icc a b) a

full_name: lowerBounds_Icc
code: theorem lowerBounds_Icc (h : a ≤ b) : lowerBounds (Icc a b) = Iic a 
goal: lowerBounds (Set.Icc a b) = Set.Iic a

full_name: isGreatest_Ioc
code: theorem isGreatest_Ioc (h : a < b) : IsGreatest (Ioc a b) b 
goal: IsGreatest (Set.Ioc a b) b

full_name: isLUB_Ioc
code: theorem isLUB_Ioc (h : a < b) : IsLUB (Ioc a b) b 
goal: IsLUB (Set.Ioc a b) b

full_name: upperBounds_Ioc
code: theorem upperBounds_Ioc (h : a < b) : upperBounds (Ioc a b) = Ici b 
goal: upperBounds (Set.Ioc a b) = Set.Ici b

full_name: isLeast_Ico
code: theorem isLeast_Ico (h : a < b) : IsLeast (Ico a b) a 
goal: IsLeast (Set.Ico a b) a

full_name: isGLB_Ico
code: theorem isGLB_Ico (h : a < b) : IsGLB (Ico a b) a 
goal: IsGLB (Set.Ico a b) a

full_name: lowerBounds_Ico
code: theorem lowerBounds_Ico (h : a < b) : lowerBounds (Ico a b) = Iic a 
goal: lowerBounds (Set.Ico a b) = Set.Iic a

full_name: isGLB_Ioo
code: theorem isGLB_Ioo {a b : γ} (h : a < b) : IsGLB (Ioo a b) a 
goal: IsGLB (Set.Ioo a b) a

full_name: lowerBounds_Ioo
code: theorem lowerBounds_Ioo {a b : γ} (hab : a < b) : lowerBounds (Ioo a b) = Iic a 
goal: lowerBounds (Set.Ioo a b) = Set.Iic a

full_name: isGLB_Ioc
code: theorem isGLB_Ioc {a b : γ} (hab : a < b) : IsGLB (Ioc a b) a 
goal: IsGLB (Set.Ioc a b) a

full_name: lowerBounds_Ioc
code: theorem lowerBounds_Ioc {a b : γ} (hab : a < b) : lowerBounds (Ioc a b) = Iic a 
goal: lowerBounds (Set.Ioc a b) = Set.Iic a

full_name: isLUB_Ioo
code: theorem isLUB_Ioo {a b : γ} (hab : a < b) : IsLUB (Ioo a b) b 
goal: IsLUB (Set.Ioo a b) b

full_name: upperBounds_Ioo
code: theorem upperBounds_Ioo {a b : γ} (hab : a < b) : upperBounds (Ioo a b) = Ici b 
goal: upperBounds (Set.Ioo a b) = Set.Ici b

full_name: isLUB_Ico
code: theorem isLUB_Ico {a b : γ} (hab : a < b) : IsLUB (Ico a b) b 
goal: IsLUB (Set.Ico a b) b

full_name: upperBounds_Ico
code: theorem upperBounds_Ico {a b : γ} (hab : a < b) : upperBounds (Ico a b) = Ici b 
goal: upperBounds (Set.Ico a b) = Set.Ici b

full_name: bddBelow_iff_subset_Ici
code: theorem bddBelow_iff_subset_Ici : BddBelow s ↔ ∃ a, s ⊆ Ici a 
goal: BddBelow s ↔ ∃ a, s ⊆ Set.Ici a

full_name: bddAbove_iff_subset_Iic
code: theorem bddAbove_iff_subset_Iic : BddAbove s ↔ ∃ a, s ⊆ Iic a 
goal: BddAbove s ↔ ∃ a, s ⊆ Set.Iic a

full_name: bddBelow_bddAbove_iff_subset_Icc
code: theorem bddBelow_bddAbove_iff_subset_Icc : BddBelow s ∧ BddAbove s ↔ ∃ a b, s ⊆ Icc a b 
goal: BddBelow s ∧ BddAbove s ↔ ∃ a b, s ⊆ Set.Icc a b

full_name: isGreatest_univ_iff
code: @[simp] theorem isGreatest_univ_iff : IsGreatest univ a ↔ IsTop a 
goal: IsGreatest Set.univ a ↔ IsTop a

full_name: isGreatest_univ
code: theorem isGreatest_univ [OrderTop α] : IsGreatest (univ : Set α) ⊤ 
goal: IsGreatest Set.univ ⊤

full_name: OrderTop.upperBounds_univ
code: @[simp]
theorem OrderTop.upperBounds_univ [PartialOrder γ] [OrderTop γ] :
    upperBounds (univ : Set γ) = {⊤} 
goal: upperBounds Set.univ = {⊤}

full_name: isLUB_univ
code: theorem isLUB_univ [OrderTop α] : IsLUB (univ : Set α) ⊤ 
goal: IsLUB Set.univ ⊤

full_name: OrderBot.lowerBounds_univ
code: @[simp]
theorem OrderBot.lowerBounds_univ [PartialOrder γ] [OrderBot γ] :
    lowerBounds (univ : Set γ) = {⊥} 
goal: lowerBounds Set.univ = {⊥}

full_name: isLeast_univ_iff
code: @[simp] theorem isLeast_univ_iff : IsLeast univ a ↔ IsBot a 
goal: IsLeast Set.univ a ↔ IsBot a

full_name: isLeast_univ
code: theorem isLeast_univ [OrderBot α] : IsLeast (univ : Set α) ⊥ 
goal: IsLeast Set.univ ⊥

full_name: isGLB_univ
code: theorem isGLB_univ [OrderBot α] : IsGLB (univ : Set α) ⊥ 
goal: IsGLB Set.univ ⊥

full_name: NoMaxOrder.upperBounds_univ
code: @[simp]
theorem NoMaxOrder.upperBounds_univ [NoMaxOrder α] : upperBounds (univ : Set α) = ∅ 
goal: upperBounds Set.univ = ∅

full_name: NoMinOrder.lowerBounds_univ
code: @[simp]
theorem NoMinOrder.lowerBounds_univ [NoMinOrder α] : lowerBounds (univ : Set α) = ∅ 
goal: lowerBounds Set.univ = ∅

full_name: not_bddAbove_univ
code: @[simp]
theorem not_bddAbove_univ [NoMaxOrder α] : ¬BddAbove (univ : Set α) 
goal: ¬BddAbove Set.univ

full_name: not_bddBelow_univ
code: @[simp]
theorem not_bddBelow_univ [NoMinOrder α] : ¬BddBelow (univ : Set α) 
goal: ¬BddBelow Set.univ

full_name: upperBounds_empty
code: @[simp]
theorem upperBounds_empty : upperBounds (∅ : Set α) = univ 
goal: upperBounds ∅ = Set.univ

full_name: lowerBounds_empty
code: @[simp]
theorem lowerBounds_empty : lowerBounds (∅ : Set α) = univ 
goal: lowerBounds ∅ = Set.univ

full_name: bddAbove_empty
code: @[simp]
theorem bddAbove_empty [Nonempty α] : BddAbove (∅ : Set α) 
goal: BddAbove ∅

full_name: bddBelow_empty
code: @[simp]
theorem bddBelow_empty [Nonempty α] : BddBelow (∅ : Set α) 
goal: BddBelow ∅

full_name: isGLB_empty_iff
code: @[simp] theorem isGLB_empty_iff : IsGLB ∅ a ↔ IsTop a 
goal: IsGLB ∅ a ↔ IsTop a

full_name: isLUB_empty_iff
code: @[simp] theorem isLUB_empty_iff : IsLUB ∅ a ↔ IsBot a 
goal: IsLUB ∅ a ↔ IsBot a

full_name: isGLB_empty
code: theorem isGLB_empty [OrderTop α] : IsGLB ∅ (⊤ : α) 
goal: IsGLB ∅ ⊤

full_name: isLUB_empty
code: theorem isLUB_empty [OrderBot α] : IsLUB ∅ (⊥ : α) 
goal: IsLUB ∅ ⊥

full_name: IsLUB.nonempty
code: theorem IsLUB.nonempty [NoMinOrder α] (hs : IsLUB s a) : s.Nonempty 
goal: s.Nonempty

full_name: IsGLB.nonempty
code: theorem IsGLB.nonempty [NoMaxOrder α] (hs : IsGLB s a) : s.Nonempty 
goal: s.Nonempty

full_name: nonempty_of_not_bddAbove
code: theorem nonempty_of_not_bddAbove [ha : Nonempty α] (h : ¬BddAbove s) : s.Nonempty 
goal: s.Nonempty

full_name: nonempty_of_not_bddBelow
code: theorem nonempty_of_not_bddBelow [Nonempty α] (h : ¬BddBelow s) : s.Nonempty 
goal: s.Nonempty

full_name: bddAbove_insert
code: /-- Adding a point to a set preserves its boundedness above. -/
@[simp]
theorem bddAbove_insert [IsDirected α (· ≤ ·)] {s : Set α} {a : α} :
    BddAbove (insert a s) ↔ BddAbove s 
goal: BddAbove (insert a s) ↔ BddAbove s

full_name: BddAbove.insert
code: protected theorem BddAbove.insert [IsDirected α (· ≤ ·)] {s : Set α} (a : α) :
    BddAbove s → BddAbove (insert a s) 
goal: BddAbove s → BddAbove (insert a s)

full_name: bddBelow_insert
code: /-- Adding a point to a set preserves its boundedness below. -/
@[simp]
theorem bddBelow_insert [IsDirected α (· ≥ ·)] {s : Set α} {a : α} :
    BddBelow (insert a s) ↔ BddBelow s 
goal: BddBelow (insert a s) ↔ BddBelow s

full_name: BddBelow.insert
code: protected theorem BddBelow.insert [IsDirected α (· ≥ ·)] {s : Set α} (a : α) :
    BddBelow s → BddBelow (insert a s) 
goal: BddBelow s → BddBelow (insert a s)

full_name: IsLUB.insert
code: protected theorem IsLUB.insert [SemilatticeSup γ] (a) {b} {s : Set γ} (hs : IsLUB s b) :
    IsLUB (insert a s) (a ⊔ b) 
goal: IsLUB (insert a s) (a ⊔ b)

full_name: IsGLB.insert
code: protected theorem IsGLB.insert [SemilatticeInf γ] (a) {b} {s : Set γ} (hs : IsGLB s b) :
    IsGLB (insert a s) (a ⊓ b) 
goal: IsGLB (insert a s) (a ⊓ b)

full_name: IsGreatest.insert
code: protected theorem IsGreatest.insert [LinearOrder γ] (a) {b} {s : Set γ} (hs : IsGreatest s b) :
    IsGreatest (insert a s) (max a b) 
goal: IsGreatest (insert a s) (max a b)

full_name: IsLeast.insert
code: protected theorem IsLeast.insert [LinearOrder γ] (a) {b} {s : Set γ} (hs : IsLeast s b) :
    IsLeast (insert a s) (min a b) 
goal: IsLeast (insert a s) (min a b)

full_name: upperBounds_insert
code: @[simp]
theorem upperBounds_insert (a : α) (s : Set α) :
    upperBounds (insert a s) = Ici a ∩ upperBounds s 
goal: upperBounds (insert a s) = Set.Ici a ∩ upperBounds s

full_name: lowerBounds_insert
code: @[simp]
theorem lowerBounds_insert (a : α) (s : Set α) :
    lowerBounds (insert a s) = Iic a ∩ lowerBounds s 
goal: lowerBounds (insert a s) = Set.Iic a ∩ lowerBounds s

full_name: OrderTop.bddAbove
code: /-- When there is a global maximum, every set is bounded above. -/
@[simp]
protected theorem OrderTop.bddAbove [OrderTop α] (s : Set α) : BddAbove s 
goal: BddAbove s

full_name: OrderBot.bddBelow
code: /-- When there is a global minimum, every set is bounded below. -/
@[simp]
protected theorem OrderBot.bddBelow [OrderBot α] (s : Set α) : BddBelow s 
goal: BddBelow s

full_name: _aux_Mathlib_Order_Bounds_Basic___macroRules_tacticBddDefault_1
code: macro "bddDefault" : tactic =>
  `(tactic| first
    | apply OrderTop.bddAbove
    | apply OrderBot.bddBelow)
goal: Lean.Macro

full_name: tacticBddDefault
code: macro "bddDefault" : tactic =>
  `(tactic| first
    | apply OrderTop.bddAbove
    | apply OrderBot.bddBelow)
goal: Lean.ParserDescr

full_name: isLUB_pair
code: theorem isLUB_pair [SemilatticeSup γ] {a b : γ} : IsLUB {a, b} (a ⊔ b) 
goal: IsLUB {a, b} (a ⊔ b)

full_name: isGLB_pair
code: theorem isGLB_pair [SemilatticeInf γ] {a b : γ} : IsGLB {a, b} (a ⊓ b) 
goal: IsGLB {a, b} (a ⊓ b)

full_name: isLeast_pair
code: theorem isLeast_pair [LinearOrder γ] {a b : γ} : IsLeast {a, b} (min a b) 
goal: IsLeast {a, b} (min a b)

full_name: isGreatest_pair
code: theorem isGreatest_pair [LinearOrder γ] {a b : γ} : IsGreatest {a, b} (max a b) 
goal: IsGreatest {a, b} (max a b)

full_name: isLUB_lowerBounds
code: @[simp]
theorem isLUB_lowerBounds : IsLUB (lowerBounds s) a ↔ IsGLB s a 
goal: IsLUB (lowerBounds s) a ↔ IsGLB s a

full_name: isGLB_upperBounds
code: @[simp]
theorem isGLB_upperBounds : IsGLB (upperBounds s) a ↔ IsLUB s a 
goal: IsGLB (upperBounds s) a ↔ IsLUB s a

full_name: lowerBounds_le_upperBounds
code: theorem lowerBounds_le_upperBounds (ha : a ∈ lowerBounds s) (hb : b ∈ upperBounds s) :
    s.Nonempty → a ≤ b
  
goal: s.Nonempty → a ≤ b

full_name: isGLB_le_isLUB
code: theorem isGLB_le_isLUB (ha : IsGLB s a) (hb : IsLUB s b) (hs : s.Nonempty) : a ≤ b 
goal: a ≤ b

full_name: isLUB_lt_iff
code: theorem isLUB_lt_iff (ha : IsLUB s a) : a < b ↔ ∃ c ∈ upperBounds s, c < b 
goal: a < b ↔ ∃ c ∈ upperBounds s, c < b

full_name: lt_isGLB_iff
code: theorem lt_isGLB_iff (ha : IsGLB s a) : b < a ↔ ∃ c ∈ lowerBounds s, b < c 
goal: b < a ↔ ∃ c ∈ lowerBounds s, b < c

full_name: le_of_isLUB_le_isGLB
code: theorem le_of_isLUB_le_isGLB {x y} (ha : IsGLB s a) (hb : IsLUB s b) (hab : b ≤ a) (hx : x ∈ s)
    (hy : y ∈ s) : x ≤ y 
goal: x ≤ y

full_name: IsLeast.unique
code: theorem IsLeast.unique (Ha : IsLeast s a) (Hb : IsLeast s b) : a = b 
goal: a = b

full_name: IsLeast.isLeast_iff_eq
code: theorem IsLeast.isLeast_iff_eq (Ha : IsLeast s a) : IsLeast s b ↔ a = b 
goal: IsLeast s b ↔ a = b

full_name: IsGreatest.unique
code: theorem IsGreatest.unique (Ha : IsGreatest s a) (Hb : IsGreatest s b) : a = b 
goal: a = b

full_name: IsGreatest.isGreatest_iff_eq
code: theorem IsGreatest.isGreatest_iff_eq (Ha : IsGreatest s a) : IsGreatest s b ↔ a = b 
goal: IsGreatest s b ↔ a = b

full_name: IsLUB.unique
code: theorem IsLUB.unique (Ha : IsLUB s a) (Hb : IsLUB s b) : a = b 
goal: a = b

full_name: IsGLB.unique
code: theorem IsGLB.unique (Ha : IsGLB s a) (Hb : IsGLB s b) : a = b 
goal: a = b

full_name: Set.subsingleton_of_isLUB_le_isGLB
code: theorem Set.subsingleton_of_isLUB_le_isGLB (Ha : IsGLB s a) (Hb : IsLUB s b) (hab : b ≤ a) :
    s.Subsingleton 
goal: s.Subsingleton

full_name: isGLB_lt_isLUB_of_ne
code: theorem isGLB_lt_isLUB_of_ne (Ha : IsGLB s a) (Hb : IsLUB s b) {x y} (Hx : x ∈ s) (Hy : y ∈ s)
    (Hxy : x ≠ y) : a < b 
goal: a < b

full_name: lt_isLUB_iff
code: theorem lt_isLUB_iff (h : IsLUB s a) : b < a ↔ ∃ c ∈ s, b < c 
goal: b < a ↔ ∃ c ∈ s, b < c

full_name: isGLB_lt_iff
code: theorem isGLB_lt_iff (h : IsGLB s a) : a < b ↔ ∃ c ∈ s, c < b 
goal: a < b ↔ ∃ c ∈ s, c < b

full_name: IsLUB.exists_between
code: theorem IsLUB.exists_between (h : IsLUB s a) (hb : b < a) : ∃ c ∈ s, b < c ∧ c ≤ a 
goal: ∃ c ∈ s, b < c ∧ c ≤ a

full_name: IsLUB.exists_between'
code: theorem IsLUB.exists_between' (h : IsLUB s a) (h' : a ∉ s) (hb : b < a) : ∃ c ∈ s, b < c ∧ c < a 
goal: ∃ c ∈ s, b < c ∧ c < a

full_name: IsGLB.exists_between
code: theorem IsGLB.exists_between (h : IsGLB s a) (hb : a < b) : ∃ c ∈ s, a ≤ c ∧ c < b 
goal: ∃ c ∈ s, a ≤ c ∧ c < b

full_name: IsGLB.exists_between'
code: theorem IsGLB.exists_between' (h : IsGLB s a) (h' : a ∉ s) (hb : a < b) : ∃ c ∈ s, a < c ∧ c < b 
goal: ∃ c ∈ s, a < c ∧ c < b

full_name: MonotoneOn.mem_upperBounds_image
code: theorem mem_upperBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) (Has : a ∈ upperBounds s)
    (Hat : a ∈ t) : f a ∈ upperBounds (f '' s) 
goal: f a ∈ upperBounds (f '' s)

full_name: MonotoneOn.mem_upperBounds_image_self
code: theorem mem_upperBounds_image_self (Hf : MonotoneOn f t) :
    a ∈ upperBounds t → a ∈ t → f a ∈ upperBounds (f '' t) 
goal: a ∈ upperBounds t → a ∈ t → f a ∈ upperBounds (f '' t)

full_name: MonotoneOn.mem_lowerBounds_image
code: theorem mem_lowerBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) (Has : a ∈ lowerBounds s)
    (Hat : a ∈ t) : f a ∈ lowerBounds (f '' s) 
goal: f a ∈ lowerBounds (f '' s)

full_name: MonotoneOn.mem_lowerBounds_image_self
code: theorem mem_lowerBounds_image_self (Hf : MonotoneOn f t) :
    a ∈ lowerBounds t → a ∈ t → f a ∈ lowerBounds (f '' t) 
goal: a ∈ lowerBounds t → a ∈ t → f a ∈ lowerBounds (f '' t)

full_name: MonotoneOn.image_upperBounds_subset_upperBounds_image
code: theorem image_upperBounds_subset_upperBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s) 
goal: f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s)

full_name: MonotoneOn.image_lowerBounds_subset_lowerBounds_image
code: theorem image_lowerBounds_subset_lowerBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s) 
goal: f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s)

full_name: MonotoneOn.map_bddAbove
code: /-- The image under a monotone function on a set `t` of a subset which has an upper bound in `t`
  is bounded above. -/
theorem map_bddAbove (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    (upperBounds s ∩ t).Nonempty → BddAbove (f '' s) 
goal: (upperBounds s ∩ t).Nonempty → BddAbove (f '' s)

full_name: MonotoneOn.map_bddBelow
code: /-- The image under a monotone function on a set `t` of a subset which has a lower bound in `t`
  is bounded below. -/
theorem map_bddBelow (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    (lowerBounds s ∩ t).Nonempty → BddBelow (f '' s) 
goal: (lowerBounds s ∩ t).Nonempty → BddBelow (f '' s)

full_name: MonotoneOn.map_isLeast
code: /-- A monotone map sends a least element of a set to a least element of its image. -/
theorem map_isLeast (Hf : MonotoneOn f t) (Ha : IsLeast t a) : IsLeast (f '' t) (f a) 
goal: IsLeast (f '' t) (f a)

full_name: MonotoneOn.map_isGreatest
code: /-- A monotone map sends a greatest element of a set to a greatest element of its image. -/
theorem map_isGreatest (Hf : MonotoneOn f t) (Ha : IsGreatest t a) : IsGreatest (f '' t) (f a) 
goal: IsGreatest (f '' t) (f a)

full_name: AntitoneOn.mem_upperBounds_image
code: theorem mem_upperBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) (Has : a ∈ lowerBounds s) :
    a ∈ t → f a ∈ upperBounds (f '' s) 
goal: a ∈ t → f a ∈ upperBounds (f '' s)

full_name: AntitoneOn.mem_upperBounds_image_self
code: theorem mem_upperBounds_image_self (Hf : AntitoneOn f t) :
    a ∈ lowerBounds t → a ∈ t → f a ∈ upperBounds (f '' t) 
goal: a ∈ lowerBounds t → a ∈ t → f a ∈ upperBounds (f '' t)

full_name: AntitoneOn.mem_lowerBounds_image
code: theorem mem_lowerBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    a ∈ upperBounds s → a ∈ t → f a ∈ lowerBounds (f '' s) 
goal: a ∈ upperBounds s → a ∈ t → f a ∈ lowerBounds (f '' s)

full_name: AntitoneOn.mem_lowerBounds_image_self
code: theorem mem_lowerBounds_image_self (Hf : AntitoneOn f t) :
    a ∈ upperBounds t → a ∈ t → f a ∈ lowerBounds (f '' t) 
goal: a ∈ upperBounds t → a ∈ t → f a ∈ lowerBounds (f '' t)

full_name: AntitoneOn.image_lowerBounds_subset_upperBounds_image
code: theorem image_lowerBounds_subset_upperBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    f '' (lowerBounds s ∩ t) ⊆ upperBounds (f '' s) 
goal: f '' (lowerBounds s ∩ t) ⊆ upperBounds (f '' s)

full_name: AntitoneOn.image_upperBounds_subset_lowerBounds_image
code: theorem image_upperBounds_subset_lowerBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    f '' (upperBounds s ∩ t) ⊆ lowerBounds (f '' s) 
goal: f '' (upperBounds s ∩ t) ⊆ lowerBounds (f '' s)

full_name: AntitoneOn.map_bddAbove
code: /-- The image under an antitone function of a set which is bounded above is bounded below. -/
theorem map_bddAbove (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    (upperBounds s ∩ t).Nonempty → BddBelow (f '' s) 
goal: (upperBounds s ∩ t).Nonempty → BddBelow (f '' s)

full_name: AntitoneOn.map_bddBelow
code: /-- The image under an antitone function of a set which is bounded below is bounded above. -/
theorem map_bddBelow (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s) 
goal: (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s)

full_name: AntitoneOn.map_isGreatest
code: /-- An antitone map sends a greatest element of a set to a least element of its image. -/
theorem map_isGreatest (Hf : AntitoneOn f t) : IsGreatest t a → IsLeast (f '' t) (f a) 
goal: IsGreatest t a → IsLeast (f '' t) (f a)

full_name: AntitoneOn.map_isLeast
code: /-- An antitone map sends a least element of a set to a greatest element of its image. -/
theorem map_isLeast (Hf : AntitoneOn f t) : IsLeast t a → IsGreatest (f '' t) (f a) 
goal: IsLeast t a → IsGreatest (f '' t) (f a)

full_name: Monotone.mem_upperBounds_image
code: theorem mem_upperBounds_image (Ha : a ∈ upperBounds s) : f a ∈ upperBounds (f '' s) 
goal: f a ∈ upperBounds (f '' s)

full_name: Monotone.mem_lowerBounds_image
code: theorem mem_lowerBounds_image (Ha : a ∈ lowerBounds s) : f a ∈ lowerBounds (f '' s) 
goal: f a ∈ lowerBounds (f '' s)

full_name: Monotone.image_upperBounds_subset_upperBounds_image
code: theorem image_upperBounds_subset_upperBounds_image (Hf : Monotone f) :
    f '' upperBounds s ⊆ upperBounds (f '' s) 
goal: f '' upperBounds s ⊆ upperBounds (f '' s)

full_name: Monotone.image_lowerBounds_subset_lowerBounds_image
code: theorem image_lowerBounds_subset_lowerBounds_image : f '' lowerBounds s ⊆ lowerBounds (f '' s) 
goal: f '' lowerBounds s ⊆ lowerBounds (f '' s)

full_name: Monotone.map_bddAbove
code: /-- The image under a monotone function of a set which is bounded above is bounded above. See also
`BddAbove.image2`. -/
theorem map_bddAbove : BddAbove s → BddAbove (f '' s)
  
goal: BddAbove s → BddAbove (f '' s)

full_name: Monotone.map_bddBelow
code: /-- The image under a monotone function of a set which is bounded below is bounded below. See also
`BddBelow.image2`. -/
theorem map_bddBelow : BddBelow s → BddBelow (f '' s)
  
goal: BddBelow s → BddBelow (f '' s)

full_name: Monotone.map_isLeast
code: /-- A monotone map sends a least element of a set to a least element of its image. -/
theorem map_isLeast (Ha : IsLeast s a) : IsLeast (f '' s) (f a) 
goal: IsLeast (f '' s) (f a)

full_name: Monotone.map_isGreatest
code: /-- A monotone map sends a greatest element of a set to a greatest element of its image. -/
theorem map_isGreatest (Ha : IsGreatest s a) : IsGreatest (f '' s) (f a) 
goal: IsGreatest (f '' s) (f a)

full_name: Antitone.mem_upperBounds_image
code: theorem mem_upperBounds_image : a ∈ lowerBounds s → f a ∈ upperBounds (f '' s) 
goal: a ∈ lowerBounds s → f a ∈ upperBounds (f '' s)

full_name: Antitone.mem_lowerBounds_image
code: theorem mem_lowerBounds_image : a ∈ upperBounds s → f a ∈ lowerBounds (f '' s) 
goal: a ∈ upperBounds s → f a ∈ lowerBounds (f '' s)

full_name: Antitone.image_lowerBounds_subset_upperBounds_image
code: theorem image_lowerBounds_subset_upperBounds_image : f '' lowerBounds s ⊆ upperBounds (f '' s) 
goal: f '' lowerBounds s ⊆ upperBounds (f '' s)

full_name: Antitone.image_upperBounds_subset_lowerBounds_image
code: theorem image_upperBounds_subset_lowerBounds_image : f '' upperBounds s ⊆ lowerBounds (f '' s) 
goal: f '' upperBounds s ⊆ lowerBounds (f '' s)

full_name: Antitone.map_bddAbove
code: /-- The image under an antitone function of a set which is bounded above is bounded below. -/
theorem map_bddAbove : BddAbove s → BddBelow (f '' s) 
goal: BddAbove s → BddBelow (f '' s)

full_name: Antitone.map_bddBelow
code: /-- The image under an antitone function of a set which is bounded below is bounded above. -/
theorem map_bddBelow : BddBelow s → BddAbove (f '' s) 
goal: BddBelow s → BddAbove (f '' s)

full_name: Antitone.map_isGreatest
code: /-- An antitone map sends a greatest element of a set to a least element of its image. -/
theorem map_isGreatest : IsGreatest s a → IsLeast (f '' s) (f a) 
goal: IsGreatest s a → IsLeast (f '' s) (f a)

full_name: Antitone.map_isLeast
code: /-- An antitone map sends a least element of a set to a greatest element of its image. -/
theorem map_isLeast : IsLeast s a → IsGreatest (f '' s) (f a) 
goal: IsLeast s a → IsGreatest (f '' s) (f a)

full_name: mem_upperBounds_image2
code: theorem mem_upperBounds_image2 (ha : a ∈ upperBounds s) (hb : b ∈ upperBounds t) :
    f a b ∈ upperBounds (image2 f s t) 
goal: f a b ∈ upperBounds (Set.image2 f s t)

full_name: mem_lowerBounds_image2
code: theorem mem_lowerBounds_image2 (ha : a ∈ lowerBounds s) (hb : b ∈ lowerBounds t) :
    f a b ∈ lowerBounds (image2 f s t) 
goal: f a b ∈ lowerBounds (Set.image2 f s t)

full_name: image2_upperBounds_upperBounds_subset
code: theorem image2_upperBounds_upperBounds_subset :
    image2 f (upperBounds s) (upperBounds t) ⊆ upperBounds (image2 f s t) 
goal: Set.image2 f (upperBounds s) (upperBounds t) ⊆ upperBounds (Set.image2 f s t)

full_name: image2_lowerBounds_lowerBounds_subset
code: theorem image2_lowerBounds_lowerBounds_subset :
    image2 f (lowerBounds s) (lowerBounds t) ⊆ lowerBounds (image2 f s t) 
goal: Set.image2 f (lowerBounds s) (lowerBounds t) ⊆ lowerBounds (Set.image2 f s t)

full_name: BddAbove.image2
code: /-- See also `Monotone.map_bddAbove`. -/
protected theorem BddAbove.image2 (h₀ : ∀ b, Monotone (swap f b)) (h₁ : ∀ a, Monotone (f a)) :
    BddAbove s → BddAbove t → BddAbove (image2 f s t) 
goal: BddAbove s → BddAbove t → BddAbove (Set.image2 f s t)

full_name: BddBelow.image2
code: /-- See also `Monotone.map_bddBelow`. -/
protected theorem BddBelow.image2 (h₀ : ∀ b, Monotone (swap f b)) (h₁ : ∀ a, Monotone (f a)) :
    BddBelow s → BddBelow t → BddBelow (image2 f s t) 
goal: BddBelow s → BddBelow t → BddBelow (Set.image2 f s t)

full_name: IsGreatest.image2
code: protected theorem IsGreatest.image2 (ha : IsGreatest s a) (hb : IsGreatest t b) :
    IsGreatest (image2 f s t) (f a b) 
goal: IsGreatest (Set.image2 f s t) (f a b)

full_name: IsLeast.image2
code: protected theorem IsLeast.image2 (ha : IsLeast s a) (hb : IsLeast t b) :
    IsLeast (image2 f s t) (f a b) 
goal: IsLeast (Set.image2 f s t) (f a b)

full_name: mem_upperBounds_image2_of_mem_upperBounds_of_mem_lowerBounds
code: theorem mem_upperBounds_image2_of_mem_upperBounds_of_mem_lowerBounds (ha : a ∈ upperBounds s)
    (hb : b ∈ lowerBounds t) : f a b ∈ upperBounds (image2 f s t) 
goal: f a b ∈ upperBounds (Set.image2 f s t)

full_name: mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_upperBounds
code: theorem mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_upperBounds (ha : a ∈ lowerBounds s)
    (hb : b ∈ upperBounds t) : f a b ∈ lowerBounds (image2 f s t) 
goal: f a b ∈ lowerBounds (Set.image2 f s t)

full_name: image2_upperBounds_lowerBounds_subset_upperBounds_image2
code: theorem image2_upperBounds_lowerBounds_subset_upperBounds_image2 :
    image2 f (upperBounds s) (lowerBounds t) ⊆ upperBounds (image2 f s t) 
goal: Set.image2 f (upperBounds s) (lowerBounds t) ⊆ upperBounds (Set.image2 f s t)

full_name: image2_lowerBounds_upperBounds_subset_lowerBounds_image2
code: theorem image2_lowerBounds_upperBounds_subset_lowerBounds_image2 :
    image2 f (lowerBounds s) (upperBounds t) ⊆ lowerBounds (image2 f s t) 
goal: Set.image2 f (lowerBounds s) (upperBounds t) ⊆ lowerBounds (Set.image2 f s t)

full_name: BddAbove.bddAbove_image2_of_bddBelow
code: theorem BddAbove.bddAbove_image2_of_bddBelow :
    BddAbove s → BddBelow t → BddAbove (Set.image2 f s t) 
goal: BddAbove s → BddBelow t → BddAbove (Set.image2 f s t)

full_name: BddBelow.bddBelow_image2_of_bddAbove
code: theorem BddBelow.bddBelow_image2_of_bddAbove :
    BddBelow s → BddAbove t → BddBelow (Set.image2 f s t) 
goal: BddBelow s → BddAbove t → BddBelow (Set.image2 f s t)

full_name: IsGreatest.isGreatest_image2_of_isLeast
code: theorem IsGreatest.isGreatest_image2_of_isLeast (ha : IsGreatest s a) (hb : IsLeast t b) :
    IsGreatest (Set.image2 f s t) (f a b) 
goal: IsGreatest (Set.image2 f s t) (f a b)

full_name: IsLeast.isLeast_image2_of_isGreatest
code: theorem IsLeast.isLeast_image2_of_isGreatest (ha : IsLeast s a) (hb : IsGreatest t b) :
    IsLeast (Set.image2 f s t) (f a b) 
goal: IsLeast (Set.image2 f s t) (f a b)

full_name: mem_upperBounds_image2_of_mem_lowerBounds
code: theorem mem_upperBounds_image2_of_mem_lowerBounds (ha : a ∈ lowerBounds s)
    (hb : b ∈ lowerBounds t) : f a b ∈ upperBounds (image2 f s t) 
goal: f a b ∈ upperBounds (Set.image2 f s t)

full_name: mem_lowerBounds_image2_of_mem_upperBounds
code: theorem mem_lowerBounds_image2_of_mem_upperBounds (ha : a ∈ upperBounds s)
    (hb : b ∈ upperBounds t) : f a b ∈ lowerBounds (image2 f s t) 
goal: f a b ∈ lowerBounds (Set.image2 f s t)

full_name: image2_upperBounds_upperBounds_subset_upperBounds_image2
code: theorem image2_upperBounds_upperBounds_subset_upperBounds_image2 :
    image2 f (lowerBounds s) (lowerBounds t) ⊆ upperBounds (image2 f s t) 
goal: Set.image2 f (lowerBounds s) (lowerBounds t) ⊆ upperBounds (Set.image2 f s t)

full_name: image2_lowerBounds_lowerBounds_subset_lowerBounds_image2
code: theorem image2_lowerBounds_lowerBounds_subset_lowerBounds_image2 :
    image2 f (upperBounds s) (upperBounds t) ⊆ lowerBounds (image2 f s t) 
goal: Set.image2 f (upperBounds s) (upperBounds t) ⊆ lowerBounds (Set.image2 f s t)

full_name: BddBelow.image2_bddAbove
code: theorem BddBelow.image2_bddAbove : BddBelow s → BddBelow t → BddAbove (Set.image2 f s t) 
goal: BddBelow s → BddBelow t → BddAbove (Set.image2 f s t)

full_name: BddAbove.image2_bddBelow
code: theorem BddAbove.image2_bddBelow : BddAbove s → BddAbove t → BddBelow (Set.image2 f s t) 
goal: BddAbove s → BddAbove t → BddBelow (Set.image2 f s t)

full_name: IsLeast.isGreatest_image2
code: theorem IsLeast.isGreatest_image2 (ha : IsLeast s a) (hb : IsLeast t b) :
    IsGreatest (Set.image2 f s t) (f a b) 
goal: IsGreatest (Set.image2 f s t) (f a b)

full_name: IsGreatest.isLeast_image2
code: theorem IsGreatest.isLeast_image2 (ha : IsGreatest s a) (hb : IsGreatest t b) :
    IsLeast (Set.image2 f s t) (f a b) 
goal: IsLeast (Set.image2 f s t) (f a b)

full_name: mem_upperBounds_image2_of_mem_upperBounds_of_mem_upperBounds
code: theorem mem_upperBounds_image2_of_mem_upperBounds_of_mem_upperBounds (ha : a ∈ lowerBounds s)
    (hb : b ∈ upperBounds t) : f a b ∈ upperBounds (image2 f s t) 
goal: f a b ∈ upperBounds (Set.image2 f s t)

full_name: mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_lowerBounds
code: theorem mem_lowerBounds_image2_of_mem_lowerBounds_of_mem_lowerBounds (ha : a ∈ upperBounds s)
    (hb : b ∈ lowerBounds t) : f a b ∈ lowerBounds (image2 f s t) 
goal: f a b ∈ lowerBounds (Set.image2 f s t)

full_name: image2_lowerBounds_upperBounds_subset_upperBounds_image2
code: theorem image2_lowerBounds_upperBounds_subset_upperBounds_image2 :
    image2 f (lowerBounds s) (upperBounds t) ⊆ upperBounds (image2 f s t) 
goal: Set.image2 f (lowerBounds s) (upperBounds t) ⊆ upperBounds (Set.image2 f s t)

full_name: image2_upperBounds_lowerBounds_subset_lowerBounds_image2
code: theorem image2_upperBounds_lowerBounds_subset_lowerBounds_image2 :
    image2 f (upperBounds s) (lowerBounds t) ⊆ lowerBounds (image2 f s t) 
goal: Set.image2 f (upperBounds s) (lowerBounds t) ⊆ lowerBounds (Set.image2 f s t)

full_name: BddBelow.bddAbove_image2_of_bddAbove
code: theorem BddBelow.bddAbove_image2_of_bddAbove :
    BddBelow s → BddAbove t → BddAbove (Set.image2 f s t) 
goal: BddBelow s → BddAbove t → BddAbove (Set.image2 f s t)

full_name: BddAbove.bddBelow_image2_of_bddAbove
code: theorem BddAbove.bddBelow_image2_of_bddAbove :
    BddAbove s → BddBelow t → BddBelow (Set.image2 f s t) 
goal: BddAbove s → BddBelow t → BddBelow (Set.image2 f s t)

full_name: IsLeast.isGreatest_image2_of_isGreatest
code: theorem IsLeast.isGreatest_image2_of_isGreatest (ha : IsLeast s a) (hb : IsGreatest t b) :
    IsGreatest (Set.image2 f s t) (f a b) 
goal: IsGreatest (Set.image2 f s t) (f a b)

full_name: IsGreatest.isLeast_image2_of_isLeast
code: theorem IsGreatest.isLeast_image2_of_isLeast (ha : IsGreatest s a) (hb : IsLeast t b) :
    IsLeast (Set.image2 f s t) (f a b) 
goal: IsLeast (Set.image2 f s t) (f a b)

full_name: bddAbove_prod
code: lemma bddAbove_prod {s : Set (α × β)} :
    BddAbove s ↔ BddAbove (Prod.fst '' s) ∧ BddAbove (Prod.snd '' s) 
goal: BddAbove s ↔ BddAbove (Prod.fst '' s) ∧ BddAbove (Prod.snd '' s)

full_name: bddBelow_prod
code: lemma bddBelow_prod {s : Set (α × β)} :
    BddBelow s ↔ BddBelow (Prod.fst '' s) ∧ BddBelow (Prod.snd '' s) 
goal: BddBelow s ↔ BddBelow (Prod.fst '' s) ∧ BddBelow (Prod.snd '' s)

full_name: bddAbove_range_prod
code: lemma bddAbove_range_prod {F : ι → α × β} :
    BddAbove (range F) ↔ BddAbove (range <| Prod.fst ∘ F) ∧ BddAbove (range <| Prod.snd ∘ F) 
goal: BddAbove (Set.range F) ↔ BddAbove (Set.range (Prod.fst ∘ F)) ∧ BddAbove (Set.range (Prod.snd ∘ F))

full_name: bddBelow_range_prod
code: lemma bddBelow_range_prod {F : ι → α × β} :
    BddBelow (range F) ↔ BddBelow (range <| Prod.fst ∘ F) ∧ BddBelow (range <| Prod.snd ∘ F) 
goal: BddBelow (Set.range F) ↔ BddBelow (Set.range (Prod.fst ∘ F)) ∧ BddBelow (Set.range (Prod.snd ∘ F))

full_name: isLUB_prod
code: theorem isLUB_prod {s : Set (α × β)} (p : α × β) :
    IsLUB s p ↔ IsLUB (Prod.fst '' s) p.1 ∧ IsLUB (Prod.snd '' s) p.2 
goal: IsLUB s p ↔ IsLUB (Prod.fst '' s) p.1 ∧ IsLUB (Prod.snd '' s) p.2

full_name: isGLB_prod
code: theorem isGLB_prod {s : Set (α × β)} (p : α × β) :
    IsGLB s p ↔ IsGLB (Prod.fst '' s) p.1 ∧ IsGLB (Prod.snd '' s) p.2 
goal: IsGLB s p ↔ IsGLB (Prod.fst '' s) p.1 ∧ IsGLB (Prod.snd '' s) p.2

full_name: bddAbove_pi
code: lemma bddAbove_pi {s : Set (∀ a, π a)} :
    BddAbove s ↔ ∀ a, BddAbove (Function.eval a '' s) 
goal: BddAbove s ↔ ∀ (a : α), BddAbove (Function.eval a '' s)

full_name: bddBelow_pi
code: lemma bddBelow_pi {s : Set (∀ a, π a)} :
    BddBelow s ↔ ∀ a, BddBelow (Function.eval a '' s) 
goal: BddBelow s ↔ ∀ (a : α), BddBelow (Function.eval a '' s)

full_name: bddAbove_range_pi
code: lemma bddAbove_range_pi {F : ι → ∀ a, π a} :
    BddAbove (range F) ↔ ∀ a, BddAbove (range fun i ↦ F i a) 
goal: BddAbove (Set.range F) ↔ ∀ (a : α), BddAbove (Set.range fun i => F i a)

full_name: bddBelow_range_pi
code: lemma bddBelow_range_pi {F : ι → ∀ a, π a} :
    BddBelow (range F) ↔ ∀ a, BddBelow (range fun i ↦ F i a) 
goal: BddBelow (Set.range F) ↔ ∀ (a : α), BddBelow (Set.range fun i => F i a)

full_name: isLUB_pi
code: theorem isLUB_pi {s : Set (∀ a, π a)} {f : ∀ a, π a} :
    IsLUB s f ↔ ∀ a, IsLUB (Function.eval a '' s) (f a) 
goal: IsLUB s f ↔ ∀ (a : α), IsLUB (Function.eval a '' s) (f a)

full_name: isGLB_pi
code: theorem isGLB_pi {s : Set (∀ a, π a)} {f : ∀ a, π a} :
    IsGLB s f ↔ ∀ a, IsGLB (Function.eval a '' s) (f a) 
goal: IsGLB s f ↔ ∀ (a : α), IsGLB (Function.eval a '' s) (f a)

full_name: IsGLB.of_image
code: theorem IsGLB.of_image [Preorder α] [Preorder β] {f : α → β} (hf : ∀ {x y}, f x ≤ f y ↔ x ≤ y)
    {s : Set α} {x : α} (hx : IsGLB (f '' s) (f x)) : IsGLB s x 
goal: IsGLB s x

full_name: IsLUB.of_image
code: theorem IsLUB.of_image [Preorder α] [Preorder β] {f : α → β} (hf : ∀ {x y}, f x ≤ f y ↔ x ≤ y)
    {s : Set α} {x : α} (hx : IsLUB (f '' s) (f x)) : IsLUB s x 
goal: IsLUB s x

full_name: BddAbove.range_mono
code: lemma BddAbove.range_mono [Preorder β] {f : α → β} (g : α → β) (h : ∀ a, f a ≤ g a)
    (hbdd : BddAbove (range g)) : BddAbove (range f) 
goal: BddAbove (Set.range f)

full_name: BddBelow.range_mono
code: lemma BddBelow.range_mono [Preorder β] (f : α → β) {g : α → β} (h : ∀ a, f a ≤ g a)
    (hbdd : BddBelow (range f)) : BddBelow (range g) 
goal: BddBelow (Set.range g)

full_name: BddAbove.range_comp
code: lemma BddAbove.range_comp {γ : Type*} [Preorder β] [Preorder γ] {f : α → β} {g : β → γ}
    (hf : BddAbove (range f)) (hg : Monotone g) : BddAbove (range (fun x => g (f x))) 
goal: BddAbove (Set.range fun x => g (f x))

full_name: BddBelow.range_comp
code: lemma BddBelow.range_comp {γ : Type*} [Preorder β] [Preorder γ] {f : α → β} {g : β → γ}
    (hf : BddBelow (range f)) (hg : Monotone g) : BddBelow (range (fun x => g (f x))) 
goal: BddBelow (Set.range fun x => g (f x))

full_name: ScottContinuous
code: /-- A function between preorders is said to be Scott continuous if it preserves `IsLUB` on directed
sets. It can be shown that a function is Scott continuous if and only if it is continuous wrt the
Scott topology.

The dual notion

```lean
∀ ⦃d : Set α⦄, d.Nonempty → DirectedOn (· ≥ ·) d → ∀ ⦃a⦄, IsGLB d a → IsGLB (f '' d) (f a)
```

does not appear to play a significant role in the literature, so is omitted here.
-/
def ScottContinuous (f : α → β) : Prop 
goal: Prop

full_name: ScottContinuous.monotone
code: protected theorem ScottContinuous.monotone (h : ScottContinuous f) : Monotone f 
goal: Monotone f