ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- isGreatest_univ_iff
@[simp] theorem isGreatest_univ_iff : IsGreatest univ a ↔ IsTop a 
Arguments: {α : Type u} [Preorder α] {a : α}
Goal: IsGreatest Set.univ a ↔ IsTop a
-- isGreatest_univ
theorem isGreatest_univ [OrderTop α] : IsGreatest (univ : Set α) ⊤ 
Arguments: {α : Type u} [Preorder α] [OrderTop α]
Goal: IsGreatest Set.univ ⊤
-- OrderTop.upperBounds_univ
@[simp]
theorem OrderTop.upperBounds_univ [PartialOrder γ] [OrderTop γ] :
    upperBounds (univ : Set γ) = {⊤} 
Arguments: {γ : Type w} [PartialOrder γ] [OrderTop γ]
Goal: upperBounds Set.univ = {⊤}
-- isLUB_univ
theorem isLUB_univ [OrderTop α] : IsLUB (univ : Set α) ⊤ 
Arguments: {α : Type u} [Preorder α] [OrderTop α]
Goal: IsLUB Set.univ ⊤
-- OrderBot.lowerBounds_univ
@[simp]
theorem OrderBot.lowerBounds_univ [PartialOrder γ] [OrderBot γ] :
    lowerBounds (univ : Set γ) = {⊥} 
Arguments: {γ : Type w} [PartialOrder γ] [OrderBot γ]
Goal: lowerBounds Set.univ = {⊥}
-- isLeast_univ_iff
@[simp] theorem isLeast_univ_iff : IsLeast univ a ↔ IsBot a 
Arguments: {α : Type u} [Preorder α] {a : α}
Goal: IsLeast Set.univ a ↔ IsBot a
-- isLeast_univ
theorem isLeast_univ [OrderBot α] : IsLeast (univ : Set α) ⊥ 
Arguments: {α : Type u} [Preorder α] [OrderBot α]
Goal: IsLeast Set.univ ⊥
-- isGLB_univ
theorem isGLB_univ [OrderBot α] : IsGLB (univ : Set α) ⊥ 
Arguments: {α : Type u} [Preorder α] [OrderBot α]
Goal: IsGLB Set.univ ⊥
-- NoMaxOrder.upperBounds_univ
@[simp]
theorem NoMaxOrder.upperBounds_univ [NoMaxOrder α] : upperBounds (univ : Set α) = ∅ 
Arguments: {α : Type u} [Preorder α] [NoMaxOrder α]
Goal: upperBounds Set.univ = ∅
-- NoMinOrder.lowerBounds_univ
@[simp]
theorem NoMinOrder.lowerBounds_univ [NoMinOrder α] : lowerBounds (univ : Set α) = ∅ 
Arguments: {α : Type u} [Preorder α] [NoMinOrder α]
Goal: lowerBounds Set.univ = ∅
-- not_bddAbove_univ
@[simp]
theorem not_bddAbove_univ [NoMaxOrder α] : ¬BddAbove (univ : Set α) 
Arguments: {α : Type u} [Preorder α] [NoMaxOrder α]
Goal: ¬BddAbove Set.univ
-- not_bddBelow_univ
@[simp]
theorem not_bddBelow_univ [NoMinOrder α] : ¬BddBelow (univ : Set α) 
Arguments: {α : Type u} [Preorder α] [NoMinOrder α]
Goal: ¬BddBelow Set.univ
-- upperBounds_empty
@[simp]
theorem upperBounds_empty : upperBounds (∅ : Set α) = univ 
Arguments: {α : Type u} [Preorder α]
Goal: upperBounds ∅ = Set.univ
-- lowerBounds_empty
@[simp]
theorem lowerBounds_empty : lowerBounds (∅ : Set α) = univ 
Arguments: {α : Type u} [Preorder α]
Goal: lowerBounds ∅ = Set.univ
-- bddAbove_empty
@[simp]
theorem bddAbove_empty [Nonempty α] : BddAbove (∅ : Set α) 
Arguments: {α : Type u} [Preorder α] [Nonempty α]
Goal: BddAbove ∅
-- bddBelow_empty
@[simp]
theorem bddBelow_empty [Nonempty α] : BddBelow (∅ : Set α) 
Arguments: {α : Type u} [Preorder α] [Nonempty α]
Goal: BddBelow ∅
-- isGLB_empty_iff
@[simp] theorem isGLB_empty_iff : IsGLB ∅ a ↔ IsTop a 
Arguments: {α : Type u} [Preorder α] {a : α}
Goal: IsGLB ∅ a ↔ IsTop a
-- isLUB_empty_iff
@[simp] theorem isLUB_empty_iff : IsLUB ∅ a ↔ IsBot a 
Arguments: {α : Type u} [Preorder α] {a : α}
Goal: IsLUB ∅ a ↔ IsBot a
-- isGLB_empty
theorem isGLB_empty [OrderTop α] : IsGLB ∅ (⊤ : α) 
Arguments: {α : Type u} [Preorder α] [OrderTop α]
Goal: IsGLB ∅ ⊤
-- isLUB_empty
theorem isLUB_empty [OrderBot α] : IsLUB ∅ (⊥ : α) 
Arguments: {α : Type u} [Preorder α] [OrderBot α]
Goal: IsLUB ∅ ⊥
-- IsLUB.nonempty
theorem IsLUB.nonempty [NoMinOrder α] (hs : IsLUB s a) : s.Nonempty 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a : α} [NoMinOrder α] (hs : IsLUB s a)
Goal: s.Nonempty
-- IsGLB.nonempty
theorem IsGLB.nonempty [NoMaxOrder α] (hs : IsGLB s a) : s.Nonempty 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a : α} [NoMaxOrder α] (hs : IsGLB s a)
Goal: s.Nonempty
-- nonempty_of_not_bddAbove
theorem nonempty_of_not_bddAbove [ha : Nonempty α] (h : ¬BddAbove s) : s.Nonempty 
Arguments: {α : Type u} [Preorder α] {s : Set α} [ha : Nonempty α] (h : ¬BddAbove s)
Goal: s.Nonempty
-- nonempty_of_not_bddBelow
theorem nonempty_of_not_bddBelow [Nonempty α] (h : ¬BddBelow s) : s.Nonempty 
Arguments: {α : Type u} [Preorder α] {s : Set α} [Nonempty α] (h : ¬BddBelow s)
Goal: s.Nonempty
-- bddAbove_insert
@[simp]
theorem bddAbove_insert [IsDirected α (· ≤ ·)] {s : Set α} {a : α} :
    BddAbove (insert a s) ↔ BddAbove s 
Arguments: {α : Type u} [Preorder α] [IsDirected α fun x x_1 => x ≤ x_1] {s : Set α} {a : α}
Goal: BddAbove (insert a s) ↔ BddAbove s
-- BddAbove.insert
protected theorem BddAbove.insert [IsDirected α (· ≤ ·)] {s : Set α} (a : α) :
    BddAbove s → BddAbove (insert a s) 
Arguments: {α : Type u} [Preorder α] [IsDirected α fun x x_1 => x ≤ x_1] {s : Set α} (a : α)
Goal: BddAbove s → BddAbove (insert a s)
-- bddBelow_insert
@[simp]
theorem bddBelow_insert [IsDirected α (· ≥ ·)] {s : Set α} {a : α} :
    BddBelow (insert a s) ↔ BddBelow s 
Arguments: {α : Type u} [Preorder α] [IsDirected α fun x x_1 => x ≥ x_1] {s : Set α} {a : α}
Goal: BddBelow (insert a s) ↔ BddBelow s
-- BddBelow.insert
protected theorem BddBelow.insert [IsDirected α (· ≥ ·)] {s : Set α} (a : α) :
    BddBelow s → BddBelow (insert a s) 
Arguments: {α : Type u} [Preorder α] [IsDirected α fun x x_1 => x ≥ x_1] {s : Set α} (a : α)
Goal: BddBelow s → BddBelow (insert a s)
-- IsLUB.insert
protected theorem IsLUB.insert [SemilatticeSup γ] (a) {b} {s : Set γ} (hs : IsLUB s b) :
    IsLUB (insert a s) (a ⊔ b) 
Arguments: {γ : Type w} [SemilatticeSup γ] (a : γ) {b : γ} {s : Set γ} (hs : IsLUB s b)
Goal: IsLUB (insert a s) (a ⊔ b)
-- IsGLB.insert
protected theorem IsGLB.insert [SemilatticeInf γ] (a) {b} {s : Set γ} (hs : IsGLB s b) :
    IsGLB (insert a s) (a ⊓ b) 
Arguments: {γ : Type w} [SemilatticeInf γ] (a : γ) {b : γ} {s : Set γ} (hs : IsGLB s b)
Goal: IsGLB (insert a s) (a ⊓ b)
-- IsGreatest.insert
protected theorem IsGreatest.insert [LinearOrder γ] (a) {b} {s : Set γ} (hs : IsGreatest s b) :
    IsGreatest (insert a s) (max a b) 
Arguments: {γ : Type w} [LinearOrder γ] (a : γ) {b : γ} {s : Set γ} (hs : IsGreatest s b)
Goal: IsGreatest (insert a s) (max a b)
-- IsLeast.insert
protected theorem IsLeast.insert [LinearOrder γ] (a) {b} {s : Set γ} (hs : IsLeast s b) :
    IsLeast (insert a s) (min a b) 
Arguments: {γ : Type w} [LinearOrder γ] (a : γ) {b : γ} {s : Set γ} (hs : IsLeast s b)
Goal: IsLeast (insert a s) (min a b)
-- upperBounds_insert
@[simp]
theorem upperBounds_insert (a : α) (s : Set α) :
    upperBounds (insert a s) = Ici a ∩ upperBounds s 
Arguments: {α : Type u} [Preorder α] (a : α) (s : Set α)
Goal: upperBounds (insert a s) = Set.Ici a ∩ upperBounds s
-- lowerBounds_insert
@[simp]
theorem lowerBounds_insert (a : α) (s : Set α) :
    lowerBounds (insert a s) = Iic a ∩ lowerBounds s 
Arguments: {α : Type u} [Preorder α] (a : α) (s : Set α)
Goal: lowerBounds (insert a s) = Set.Iic a ∩ lowerBounds s
-- OrderTop.bddAbove
@[simp]
protected theorem OrderTop.bddAbove [OrderTop α] (s : Set α) : BddAbove s 
Arguments: {α : Type u} [Preorder α] [OrderTop α] (s : Set α)
Goal: BddAbove s
-- OrderBot.bddBelow
@[simp]
protected theorem OrderBot.bddBelow [OrderBot α] (s : Set α) : BddBelow s 
Arguments: {α : Type u} [Preorder α] [OrderBot α] (s : Set α)
Goal: BddBelow s
-- isLUB_pair
theorem isLUB_pair [SemilatticeSup γ] {a b : γ} : IsLUB {a, b} (a ⊔ b) 
Arguments: {γ : Type w} [SemilatticeSup γ] {a b : γ}
Goal: IsLUB {a, b} (a ⊔ b)
-- isGLB_pair
theorem isGLB_pair [SemilatticeInf γ] {a b : γ} : IsGLB {a, b} (a ⊓ b) 
Arguments: {γ : Type w} [SemilatticeInf γ] {a b : γ}
Goal: IsGLB {a, b} (a ⊓ b)
-- isLeast_pair
theorem isLeast_pair [LinearOrder γ] {a b : γ} : IsLeast {a, b} (min a b) 
Arguments: {γ : Type w} [LinearOrder γ] {a b : γ}
Goal: IsLeast {a, b} (min a b)
-- isGreatest_pair
theorem isGreatest_pair [LinearOrder γ] {a b : γ} : IsGreatest {a, b} (max a b) 
Arguments: {γ : Type w} [LinearOrder γ] {a b : γ}
Goal: IsGreatest {a, b} (max a b)
-- isLUB_lowerBounds
@[simp]
theorem isLUB_lowerBounds : IsLUB (lowerBounds s) a ↔ IsGLB s a 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a : α}
Goal: IsLUB (lowerBounds s) a ↔ IsGLB s a
-- isGLB_upperBounds
@[simp]
theorem isGLB_upperBounds : IsGLB (upperBounds s) a ↔ IsLUB s a 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a : α}
Goal: IsGLB (upperBounds s) a ↔ IsLUB s a
-- lowerBounds_le_upperBounds
theorem lowerBounds_le_upperBounds (ha : a ∈ lowerBounds s) (hb : b ∈ upperBounds s) :
    s.Nonempty → a ≤ b
  
Arguments: {α : Type u} [Preorder α] {s : Set α} {a b : α} (ha : a ∈ lowerBounds s) (hb : b ∈ upperBounds s)
Goal: s.Nonempty → a ≤ b
-- isGLB_le_isLUB
theorem isGLB_le_isLUB (ha : IsGLB s a) (hb : IsLUB s b) (hs : s.Nonempty) : a ≤ b 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a b : α} (ha : IsGLB s a) (hb : IsLUB s b) (hs : s.Nonempty)
Goal: a ≤ b
-- isLUB_lt_iff
theorem isLUB_lt_iff (ha : IsLUB s a) : a < b ↔ ∃ c ∈ upperBounds s, c < b 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a b : α} (ha : IsLUB s a)
Goal: a < b ↔ ∃ c ∈ upperBounds s, c < b
-- lt_isGLB_iff
theorem lt_isGLB_iff (ha : IsGLB s a) : b < a ↔ ∃ c ∈ lowerBounds s, b < c 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a b : α} (ha : IsGLB s a)
Goal: b < a ↔ ∃ c ∈ lowerBounds s, b < c
-- le_of_isLUB_le_isGLB
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 
Arguments: {α : Type u} [Preorder α] {s : Set α} {a b x y : α} (ha : IsGLB s a) (hb : IsLUB s b) (hab : b ≤ a) (hx : x ∈ s) (hy : y ∈ s)
Goal: x ≤ y
-- IsLeast.unique
theorem IsLeast.unique (Ha : IsLeast s a) (Hb : IsLeast s b) : a = b 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsLeast s a) (Hb : IsLeast s b)
Goal: a = b
-- IsLeast.isLeast_iff_eq
theorem IsLeast.isLeast_iff_eq (Ha : IsLeast s a) : IsLeast s b ↔ a = b 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsLeast s a)
Goal: IsLeast s b ↔ a = b
-- IsGreatest.unique
theorem IsGreatest.unique (Ha : IsGreatest s a) (Hb : IsGreatest s b) : a = b 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsGreatest s a) (Hb : IsGreatest s b)
Goal: a = b
-- IsGreatest.isGreatest_iff_eq
theorem IsGreatest.isGreatest_iff_eq (Ha : IsGreatest s a) : IsGreatest s b ↔ a = b 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsGreatest s a)
Goal: IsGreatest s b ↔ a = b
-- IsLUB.unique
theorem IsLUB.unique (Ha : IsLUB s a) (Hb : IsLUB s b) : a = b 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsLUB s a) (Hb : IsLUB s b)
Goal: a = b
-- IsGLB.unique
theorem IsGLB.unique (Ha : IsGLB s a) (Hb : IsGLB s b) : a = b 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsGLB s a) (Hb : IsGLB s b)
Goal: a = b
-- Set.subsingleton_of_isLUB_le_isGLB
theorem Set.subsingleton_of_isLUB_le_isGLB (Ha : IsGLB s a) (Hb : IsLUB s b) (hab : b ≤ a) :
    s.Subsingleton 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsGLB s a) (Hb : IsLUB s b) (hab : b ≤ a)
Goal: s.Subsingleton
-- isGLB_lt_isLUB_of_ne
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 
Arguments: {α : Type u} [PartialOrder α] {s : Set α} {a b : α} (Ha : IsGLB s a) (Hb : IsLUB s b) {x y : α} (Hx : x ∈ s) (Hy : y ∈ s) (Hxy : x ≠ y)
Goal: a < b
-- lt_isLUB_iff
theorem lt_isLUB_iff (h : IsLUB s a) : b < a ↔ ∃ c ∈ s, b < c 
Arguments: {α : Type u} [LinearOrder α] {s : Set α} {a b : α} (h : IsLUB s a)
Goal: b < a ↔ ∃ c ∈ s, b < c
-- isGLB_lt_iff
theorem isGLB_lt_iff (h : IsGLB s a) : a < b ↔ ∃ c ∈ s, c < b 
Arguments: {α : Type u} [LinearOrder α] {s : Set α} {a b : α} (h : IsGLB s a)
Goal: a < b ↔ ∃ c ∈ s, c < b
-- IsLUB.exists_between
theorem IsLUB.exists_between (h : IsLUB s a) (hb : b < a) : ∃ c ∈ s, b < c ∧ c ≤ a 
Arguments: {α : Type u} [LinearOrder α] {s : Set α} {a b : α} (h : IsLUB s a) (hb : b < a)
Goal: ∃ c ∈ s, b < c ∧ c ≤ a
-- IsLUB.exists_between'
theorem IsLUB.exists_between' (h : IsLUB s a) (h' : a ∉ s) (hb : b < a) : ∃ c ∈ s, b < c ∧ c < a 
Arguments: {α : Type u} [LinearOrder α] {s : Set α} {a b : α} (h : IsLUB s a) (h' : a ∉ s) (hb : b < a)
Goal: ∃ c ∈ s, b < c ∧ c < a
-- IsGLB.exists_between
theorem IsGLB.exists_between (h : IsGLB s a) (hb : a < b) : ∃ c ∈ s, a ≤ c ∧ c < b 
Arguments: {α : Type u} [LinearOrder α] {s : Set α} {a b : α} (h : IsGLB s a) (hb : a < b)
Goal: ∃ c ∈ s, a ≤ c ∧ c < b
-- IsGLB.exists_between'
theorem IsGLB.exists_between' (h : IsGLB s a) (h' : a ∉ s) (hb : a < b) : ∃ c ∈ s, a < c ∧ c < b 
Arguments: {α : Type u} [LinearOrder α] {s : Set α} {a b : α} (h : IsGLB s a) (h' : a ∉ s) (hb : a < b)
Goal: ∃ c ∈ s, a < c ∧ c < b
-- MonotoneOn.mem_upperBounds_image
theorem mem_upperBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) (Has : a ∈ upperBounds s)
    (Hat : a ∈ t) : f a ∈ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} {a : α} (Hf : MonotoneOn f t) (Hst : s ⊆ t) (Has : a ∈ upperBounds s) (Hat : a ∈ t)
Goal: f a ∈ upperBounds (f '' s)
-- MonotoneOn.mem_upperBounds_image_self
theorem mem_upperBounds_image_self (Hf : MonotoneOn f t) :
    a ∈ upperBounds t → a ∈ t → f a ∈ upperBounds (f '' t) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : MonotoneOn f t)
Goal: a ∈ upperBounds t → a ∈ t → f a ∈ upperBounds (f '' t)
-- MonotoneOn.mem_lowerBounds_image
theorem mem_lowerBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) (Has : a ∈ lowerBounds s)
    (Hat : a ∈ t) : f a ∈ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} {a : α} (Hf : MonotoneOn f t) (Hst : s ⊆ t) (Has : a ∈ lowerBounds s) (Hat : a ∈ t)
Goal: f a ∈ lowerBounds (f '' s)
-- MonotoneOn.mem_lowerBounds_image_self
theorem mem_lowerBounds_image_self (Hf : MonotoneOn f t) :
    a ∈ lowerBounds t → a ∈ t → f a ∈ lowerBounds (f '' t) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : MonotoneOn f t)
Goal: a ∈ lowerBounds t → a ∈ t → f a ∈ lowerBounds (f '' t)
-- MonotoneOn.image_upperBounds_subset_upperBounds_image
theorem image_upperBounds_subset_upperBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : MonotoneOn f t) (Hst : s ⊆ t)
Goal: f '' (upperBounds s ∩ t) ⊆ upperBounds (f '' s)
-- MonotoneOn.image_lowerBounds_subset_lowerBounds_image
theorem image_lowerBounds_subset_lowerBounds_image (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : MonotoneOn f t) (Hst : s ⊆ t)
Goal: f '' (lowerBounds s ∩ t) ⊆ lowerBounds (f '' s)
-- MonotoneOn.map_bddAbove
theorem map_bddAbove (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    (upperBounds s ∩ t).Nonempty → BddAbove (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : MonotoneOn f t) (Hst : s ⊆ t)
Goal: (upperBounds s ∩ t).Nonempty → BddAbove (f '' s)
-- MonotoneOn.map_bddBelow
theorem map_bddBelow (Hf : MonotoneOn f t) (Hst : s ⊆ t) :
    (lowerBounds s ∩ t).Nonempty → BddBelow (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : MonotoneOn f t) (Hst : s ⊆ t)
Goal: (lowerBounds s ∩ t).Nonempty → BddBelow (f '' s)
-- MonotoneOn.map_isLeast
theorem map_isLeast (Hf : MonotoneOn f t) (Ha : IsLeast t a) : IsLeast (f '' t) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : MonotoneOn f t) (Ha : IsLeast t a)
Goal: IsLeast (f '' t) (f a)
-- MonotoneOn.map_isGreatest
theorem map_isGreatest (Hf : MonotoneOn f t) (Ha : IsGreatest t a) : IsGreatest (f '' t) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : MonotoneOn f t) (Ha : IsGreatest t a)
Goal: IsGreatest (f '' t) (f a)
-- AntitoneOn.mem_upperBounds_image
theorem mem_upperBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) (Has : a ∈ lowerBounds s) :
    a ∈ t → f a ∈ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} {a : α} (Hf : AntitoneOn f t) (Hst : s ⊆ t) (Has : a ∈ lowerBounds s)
Goal: a ∈ t → f a ∈ upperBounds (f '' s)
-- AntitoneOn.mem_upperBounds_image_self
theorem mem_upperBounds_image_self (Hf : AntitoneOn f t) :
    a ∈ lowerBounds t → a ∈ t → f a ∈ upperBounds (f '' t) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : AntitoneOn f t)
Goal: a ∈ lowerBounds t → a ∈ t → f a ∈ upperBounds (f '' t)
-- AntitoneOn.mem_lowerBounds_image
theorem mem_lowerBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    a ∈ upperBounds s → a ∈ t → f a ∈ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} {a : α} (Hf : AntitoneOn f t) (Hst : s ⊆ t)
Goal: a ∈ upperBounds s → a ∈ t → f a ∈ lowerBounds (f '' s)
-- AntitoneOn.mem_lowerBounds_image_self
theorem mem_lowerBounds_image_self (Hf : AntitoneOn f t) :
    a ∈ upperBounds t → a ∈ t → f a ∈ lowerBounds (f '' t) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : AntitoneOn f t)
Goal: a ∈ upperBounds t → a ∈ t → f a ∈ lowerBounds (f '' t)
-- AntitoneOn.image_lowerBounds_subset_upperBounds_image
theorem image_lowerBounds_subset_upperBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    f '' (lowerBounds s ∩ t) ⊆ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : AntitoneOn f t) (Hst : s ⊆ t)
Goal: f '' (lowerBounds s ∩ t) ⊆ upperBounds (f '' s)
-- AntitoneOn.image_upperBounds_subset_lowerBounds_image
theorem image_upperBounds_subset_lowerBounds_image (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    f '' (upperBounds s ∩ t) ⊆ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : AntitoneOn f t) (Hst : s ⊆ t)
Goal: f '' (upperBounds s ∩ t) ⊆ lowerBounds (f '' s)
-- AntitoneOn.map_bddAbove
theorem map_bddAbove (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    (upperBounds s ∩ t).Nonempty → BddBelow (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : AntitoneOn f t) (Hst : s ⊆ t)
Goal: (upperBounds s ∩ t).Nonempty → BddBelow (f '' s)
-- AntitoneOn.map_bddBelow
theorem map_bddBelow (Hf : AntitoneOn f t) (Hst : s ⊆ t) :
    (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s t : Set α} (Hf : AntitoneOn f t) (Hst : s ⊆ t)
Goal: (lowerBounds s ∩ t).Nonempty → BddAbove (f '' s)
-- AntitoneOn.map_isGreatest
theorem map_isGreatest (Hf : AntitoneOn f t) : IsGreatest t a → IsLeast (f '' t) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : AntitoneOn f t)
Goal: IsGreatest t a → IsLeast (f '' t) (f a)
-- AntitoneOn.map_isLeast
theorem map_isLeast (Hf : AntitoneOn f t) : IsLeast t a → IsGreatest (f '' t) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {t : Set α} {a : α} (Hf : AntitoneOn f t)
Goal: IsLeast t a → IsGreatest (f '' t) (f a)
-- Monotone.mem_upperBounds_image
theorem mem_upperBounds_image (Ha : a ∈ upperBounds s) : f a ∈ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (Hf : Monotone f) {a : α} {s : Set α} (Ha : a ∈ upperBounds s)
Goal: f a ∈ upperBounds (f '' s)
-- Monotone.mem_lowerBounds_image
theorem mem_lowerBounds_image (Ha : a ∈ lowerBounds s) : f a ∈ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (Hf : Monotone f) {a : α} {s : Set α} (Ha : a ∈ lowerBounds s)
Goal: f a ∈ lowerBounds (f '' s)
-- Monotone.image_upperBounds_subset_upperBounds_image
theorem image_upperBounds_subset_upperBounds_image (Hf : Monotone f) :
    f '' upperBounds s ⊆ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} {s : Set α} (Hf : Monotone f)
Goal: f '' upperBounds s ⊆ upperBounds (f '' s)
-- Monotone.image_lowerBounds_subset_lowerBounds_image
theorem image_lowerBounds_subset_lowerBounds_image : f '' lowerBounds s ⊆ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (Hf : Monotone f) {s : Set α}
Goal: f '' lowerBounds s ⊆ lowerBounds (f '' s)
-- Monotone.map_bddAbove
theorem map_bddAbove : BddAbove s → BddAbove (f '' s)
  
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (Hf : Monotone f) {s : Set α}
Goal: BddAbove s → BddAbove (f '' s)
-- Monotone.map_bddBelow
theorem map_bddBelow : BddBelow s → BddBelow (f '' s)
  
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (Hf : Monotone f) {s : Set α}
Goal: BddBelow s → BddBelow (f '' s)
-- Monotone.map_isLeast
theorem map_isLeast (Ha : IsLeast s a) : IsLeast (f '' s) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (Hf : Monotone f) {a : α} {s : Set α} (Ha : IsLeast s a)
Goal: IsLeast (f '' s) (f a)
-- Monotone.map_isGreatest
theorem map_isGreatest (Ha : IsGreatest s a) : IsGreatest (f '' s) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (Hf : Monotone f) {a : α} {s : Set α} (Ha : IsGreatest s a)
Goal: IsGreatest (f '' s) (f a)
-- Antitone.mem_upperBounds_image
theorem mem_upperBounds_image : a ∈ lowerBounds s → f a ∈ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {a : α} {s : Set α}
Goal: a ∈ lowerBounds s → f a ∈ upperBounds (f '' s)
-- Antitone.mem_lowerBounds_image
theorem mem_lowerBounds_image : a ∈ upperBounds s → f a ∈ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {a : α} {s : Set α}
Goal: a ∈ upperBounds s → f a ∈ lowerBounds (f '' s)
-- Antitone.image_lowerBounds_subset_upperBounds_image
theorem image_lowerBounds_subset_upperBounds_image : f '' lowerBounds s ⊆ upperBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {s : Set α}
Goal: f '' lowerBounds s ⊆ upperBounds (f '' s)
-- Antitone.image_upperBounds_subset_lowerBounds_image
theorem image_upperBounds_subset_lowerBounds_image : f '' upperBounds s ⊆ lowerBounds (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {s : Set α}
Goal: f '' upperBounds s ⊆ lowerBounds (f '' s)
-- Antitone.map_bddAbove
theorem map_bddAbove : BddAbove s → BddBelow (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {s : Set α}
Goal: BddAbove s → BddBelow (f '' s)
-- Antitone.map_bddBelow
theorem map_bddBelow : BddBelow s → BddAbove (f '' s) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {s : Set α}
Goal: BddBelow s → BddAbove (f '' s)
-- Antitone.map_isGreatest
theorem map_isGreatest : IsGreatest s a → IsLeast (f '' s) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {a : α} {s : Set α}
Goal: IsGreatest s a → IsLeast (f '' s) (f a)
-- Antitone.map_isLeast
theorem map_isLeast : IsLeast s a → IsGreatest (f '' s) (f a) 
Arguments: {α : Type u} {β : Type v} [Preorder α] [Preorder β] {f : α → β} (hf : Antitone f) {a : α} {s : Set α}
Goal: IsLeast s a → IsGreatest (f '' s) (f a)
-- mem_upperBounds_image2
theorem mem_upperBounds_image2 (ha : a ∈ upperBounds s) (hb : b ∈ upperBounds t) :
    f a b ∈ upperBounds (image2 f s t) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [Preorder α] [Preorder β] [Preorder γ] {f : α → β → γ} {s : Set α} {t : Set β} {a : α} {b : β} (h₀ : ∀ (b : β), Monotone (Function.swap f b)) (h₁ : ∀ (a : α), Monotone (f a)) (ha : a ∈ upperBounds s) (hb : b ∈ upperBounds t)
Goal: f a b ∈ upperBounds (Set.image2 f s t)