File: Mathlib/Topology/Order/OrderClosed.lean

full_name: ClosedIicTopology.isClosed_Iic
code: /-- If `α` is a topological space and a preorder, `ClosedIicTopology α` means that `Iic a` is
closed for all `a : α`. -/
class ClosedIicTopology (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  /-- For any `a`, the set `(-∞, a]` is closed. -/
  isClosed_Iic (a : α) : IsClosed (Iic a)
goal: IsClosed (Set.Iic a)

full_name: ClosedIicTopology
code: /-- If `α` is a topological space and a preorder, `ClosedIicTopology α` means that `Iic a` is
closed for all `a : α`. -/
class ClosedIicTopology (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  /-- For any `a`, the set `(-∞, a]` is closed. -/
  isClosed_Iic (a : α) : IsClosed (Iic a)
goal: Prop

full_name: ClosedIciTopology
code: /-- If `α` is a topological space and a preorder, `ClosedIciTopology α` means that `Ici a` is
closed for all `a : α`. -/
class ClosedIciTopology (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  /-- For any `a`, the set `[a, +∞)` is closed. -/
  isClosed_Ici (a : α) : IsClosed (Ici a)
goal: Prop

full_name: ClosedIciTopology.isClosed_Ici
code: /-- If `α` is a topological space and a preorder, `ClosedIciTopology α` means that `Ici a` is
closed for all `a : α`. -/
class ClosedIciTopology (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  /-- For any `a`, the set `[a, +∞)` is closed. -/
  isClosed_Ici (a : α) : IsClosed (Ici a)
goal: IsClosed (Set.Ici a)

full_name: OrderClosedTopology
code: /-- A topology on a set which is both a topological space and a preorder is _order-closed_ if the
set of points `(x, y)` with `x ≤ y` is closed in the product space. We introduce this as a mixin.
This property is satisfied for the order topology on a linear order, but it can be satisfied more
generally, and suffices to derive many interesting properties relating order and topology. -/
class OrderClosedTopology (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  /-- The set `{ (x, y) | x ≤ y }` is a closed set. -/
  isClosed_le' : IsClosed { p : α × α | p.1 ≤ p.2 }
goal: Prop

full_name: OrderClosedTopology.isClosed_le'
code: /-- A topology on a set which is both a topological space and a preorder is _order-closed_ if the
set of points `(x, y)` with `x ≤ y` is closed in the product space. We introduce this as a mixin.
This property is satisfied for the order topology on a linear order, but it can be satisfied more
generally, and suffices to derive many interesting properties relating order and topology. -/
class OrderClosedTopology (α : Type*) [TopologicalSpace α] [Preorder α] : Prop where
  /-- The set `{ (x, y) | x ≤ y }` is a closed set. -/
  isClosed_le' : IsClosed { p : α × α | p.1 ≤ p.2 }
goal: IsClosed {p | p.1 ≤ p.2}

full_name: instFirstCountableTopologyOrderDual
code: instance [TopologicalSpace α] [h : FirstCountableTopology α] : FirstCountableTopology αᵒᵈ 
goal: FirstCountableTopology αᵒᵈ

full_name: instSecondCountableTopologyOrderDual
code: instance [TopologicalSpace α] [h : SecondCountableTopology α] : SecondCountableTopology αᵒᵈ 
goal: SecondCountableTopology αᵒᵈ

full_name: Dense.orderDual
code: theorem Dense.orderDual [TopologicalSpace α] {s : Set α} (hs : Dense s) :
    Dense (OrderDual.ofDual ⁻¹' s) 
goal: Dense (⇑OrderDual.ofDual ⁻¹' s)

full_name: BddAbove.of_closure
code: protected lemma BddAbove.of_closure : BddAbove (closure s) → BddAbove s 
goal: BddAbove (closure s) → BddAbove s

full_name: BddBelow.of_closure
code: protected lemma BddBelow.of_closure : BddBelow (closure s) → BddBelow s 
goal: BddBelow (closure s) → BddBelow s

full_name: isClosed_Iic
code: theorem isClosed_Iic : IsClosed (Iic a) 
goal: IsClosed (Set.Iic a)

full_name: ClosedIicTopology.isClosed_le'
code: @[deprecated isClosed_Iic (since := "2024-02-15")]
lemma ClosedIicTopology.isClosed_le' (a : α) : IsClosed {x | x ≤ a} 
goal: IsClosed {x | x ≤ a}

full_name: instClosedIciTopologyOrderDual
code: instance : ClosedIciTopology αᵒᵈ 
goal: ClosedIciTopology αᵒᵈ

full_name: closure_Iic
code: @[simp]
theorem closure_Iic (a : α) : closure (Iic a) = Iic a 
goal: closure (Set.Iic a) = Set.Iic a

full_name: le_of_tendsto_of_frequently
code: theorem le_of_tendsto_of_frequently {x : Filter β} (lim : Tendsto f x (𝓝 a))
    (h : ∃ᶠ c in x, f c ≤ b) : a ≤ b 
goal: a ≤ b

full_name: le_of_tendsto
code: theorem le_of_tendsto {x : Filter β} [NeBot x] (lim : Tendsto f x (𝓝 a))
    (h : ∀ᶠ c in x, f c ≤ b) : a ≤ b 
goal: a ≤ b

full_name: le_of_tendsto'
code: theorem le_of_tendsto' {x : Filter β} [NeBot x] (lim : Tendsto f x (𝓝 a))
    (h : ∀ c, f c ≤ b) : a ≤ b 
goal: a ≤ b

full_name: upperBounds_closure
code: @[simp] lemma upperBounds_closure (s : Set α) : upperBounds (closure s : Set α) = upperBounds s 
goal: upperBounds (closure s) = upperBounds s

full_name: bddAbove_closure
code: @[simp] lemma bddAbove_closure : BddAbove (closure s) ↔ BddAbove s 
goal: BddAbove (closure s) ↔ BddAbove s

full_name: disjoint_nhds_atBot_iff
code: @[simp]
theorem disjoint_nhds_atBot_iff : Disjoint (𝓝 a) atBot ↔ ¬IsBot a 
goal: Disjoint (𝓝 a) Filter.atBot ↔ ¬IsBot a

full_name: disjoint_nhds_atBot
code: theorem disjoint_nhds_atBot (a : α) : Disjoint (𝓝 a) atBot 
goal: Disjoint (𝓝 a) Filter.atBot

full_name: inf_nhds_atBot
code: @[simp]
theorem inf_nhds_atBot (a : α) : 𝓝 a ⊓ atBot = ⊥ 
goal: 𝓝 a ⊓ Filter.atBot = ⊥

full_name: not_tendsto_nhds_of_tendsto_atBot
code: theorem not_tendsto_nhds_of_tendsto_atBot (hf : Tendsto f l atBot) (a : α) : ¬Tendsto f l (𝓝 a) 
goal: ¬Filter.Tendsto f l (𝓝 a)

full_name: not_tendsto_atBot_of_tendsto_nhds
code: theorem not_tendsto_atBot_of_tendsto_nhds (hf : Tendsto f l (𝓝 a)) : ¬Tendsto f l atBot 
goal: ¬Filter.Tendsto f l Filter.atBot

full_name: isOpen_Ioi
code: theorem isOpen_Ioi : IsOpen (Ioi a) 
goal: IsOpen (Set.Ioi a)

full_name: interior_Ioi
code: @[simp]
theorem interior_Ioi : interior (Ioi a) = Ioi a 
goal: interior (Set.Ioi a) = Set.Ioi a

full_name: Ioi_mem_nhds
code: theorem Ioi_mem_nhds (h : a < b) : Ioi a ∈ 𝓝 b 
goal: Set.Ioi a ∈ 𝓝 b

full_name: eventually_gt_nhds
code: theorem eventually_gt_nhds (hab : b < a) : ∀ᶠ x in 𝓝 a, b < x 
goal: ∀ᶠ (x : α) in 𝓝 a, b < x

full_name: Ici_mem_nhds
code: theorem Ici_mem_nhds (h : a < b) : Ici a ∈ 𝓝 b 
goal: Set.Ici a ∈ 𝓝 b

full_name: eventually_ge_nhds
code: theorem eventually_ge_nhds (hab : b < a) : ∀ᶠ x in 𝓝 a, b ≤ x 
goal: ∀ᶠ (x : α) in 𝓝 a, b ≤ x

full_name: eventually_gt_of_tendsto_gt
code: theorem eventually_gt_of_tendsto_gt {l : Filter γ} {f : γ → α} {u v : α} (hv : u < v)
    (h : Filter.Tendsto f l (𝓝 v)) : ∀ᶠ a in l, u < f a 
goal: ∀ᶠ (a : γ) in l, u < f a

full_name: eventually_ge_of_tendsto_gt
code: theorem eventually_ge_of_tendsto_gt {l : Filter γ} {f : γ → α} {u v : α} (hv : u < v)
    (h : Tendsto f l (𝓝 v)) : ∀ᶠ a in l, u ≤ f a 
goal: ∀ᶠ (a : γ) in l, u ≤ f a

full_name: Dense.exists_gt
code: protected theorem Dense.exists_gt [NoMaxOrder α] {s : Set α} (hs : Dense s) (x : α) :
    ∃ y ∈ s, x < y 
goal: ∃ y ∈ s, x < y

full_name: Dense.exists_ge
code: protected theorem Dense.exists_ge [NoMaxOrder α] {s : Set α} (hs : Dense s) (x : α) :
    ∃ y ∈ s, x ≤ y 
goal: ∃ y ∈ s, x ≤ y

full_name: Dense.exists_ge'
code: theorem Dense.exists_ge' {s : Set α} (hs : Dense s) (htop : ∀ x, IsTop x → x ∈ s) (x : α) :
    ∃ y ∈ s, x ≤ y 
goal: ∃ y ∈ s, x ≤ y

full_name: Ioo_mem_nhdsWithin_Iio'
code: theorem Ioo_mem_nhdsWithin_Iio' (H : a < b) : Ioo a b ∈ 𝓝[<] b 
goal: Set.Ioo a b ∈ 𝓝[<] b

full_name: Ioo_mem_nhdsWithin_Iio
code: theorem Ioo_mem_nhdsWithin_Iio (H : b ∈ Ioc a c) : Ioo a c ∈ 𝓝[<] b 
goal: Set.Ioo a c ∈ 𝓝[<] b

full_name: CovBy.nhdsWithin_Iio
code: theorem CovBy.nhdsWithin_Iio (h : a ⋖ b) : 𝓝[<] b = ⊥ 
goal: 𝓝[<] b = ⊥

full_name: Ico_mem_nhdsWithin_Iio
code: theorem Ico_mem_nhdsWithin_Iio (H : b ∈ Ioc a c) : Ico a c ∈ 𝓝[<] b 
goal: Set.Ico a c ∈ 𝓝[<] b

full_name: Ico_mem_nhdsWithin_Iio'
code: theorem Ico_mem_nhdsWithin_Iio' (H : a < b) : Ico a b ∈ 𝓝[<] b 
goal: Set.Ico a b ∈ 𝓝[<] b

full_name: Ioc_mem_nhdsWithin_Iio
code: theorem Ioc_mem_nhdsWithin_Iio (H : b ∈ Ioc a c) : Ioc a c ∈ 𝓝[<] b 
goal: Set.Ioc a c ∈ 𝓝[<] b

full_name: Ioc_mem_nhdsWithin_Iio'
code: theorem Ioc_mem_nhdsWithin_Iio' (H : a < b) : Ioc a b ∈ 𝓝[<] b 
goal: Set.Ioc a b ∈ 𝓝[<] b

full_name: Icc_mem_nhdsWithin_Iio
code: theorem Icc_mem_nhdsWithin_Iio (H : b ∈ Ioc a c) : Icc a c ∈ 𝓝[<] b 
goal: Set.Icc a c ∈ 𝓝[<] b

full_name: Icc_mem_nhdsWithin_Iio'
code: theorem Icc_mem_nhdsWithin_Iio' (H : a < b) : Icc a b ∈ 𝓝[<] b 
goal: Set.Icc a b ∈ 𝓝[<] b

full_name: nhdsWithin_Ico_eq_nhdsWithin_Iio
code: @[simp]
theorem nhdsWithin_Ico_eq_nhdsWithin_Iio (h : a < b) : 𝓝[Ico a b] b = 𝓝[<] b 
goal: 𝓝[Set.Ico a b] b = 𝓝[<] b

full_name: nhdsWithin_Ioo_eq_nhdsWithin_Iio
code: @[simp]
theorem nhdsWithin_Ioo_eq_nhdsWithin_Iio (h : a < b) : 𝓝[Ioo a b] b = 𝓝[<] b 
goal: 𝓝[Set.Ioo a b] b = 𝓝[<] b

full_name: continuousWithinAt_Ico_iff_Iio
code: @[simp]
theorem continuousWithinAt_Ico_iff_Iio (h : a < b) :
    ContinuousWithinAt f (Ico a b) b ↔ ContinuousWithinAt f (Iio b) b 
goal: ContinuousWithinAt f (Set.Ico a b) b ↔ ContinuousWithinAt f (Set.Iio b) b

full_name: continuousWithinAt_Ioo_iff_Iio
code: @[simp]
theorem continuousWithinAt_Ioo_iff_Iio (h : a < b) :
    ContinuousWithinAt f (Ioo a b) b ↔ ContinuousWithinAt f (Iio b) b 
goal: ContinuousWithinAt f (Set.Ioo a b) b ↔ ContinuousWithinAt f (Set.Iio b) b

full_name: Ioc_mem_nhdsWithin_Iic'
code: theorem Ioc_mem_nhdsWithin_Iic' (H : a < b) : Ioc a b ∈ 𝓝[≤] b 
goal: Set.Ioc a b ∈ 𝓝[≤] b

full_name: Ioo_mem_nhdsWithin_Iic
code: theorem Ioo_mem_nhdsWithin_Iic (H : b ∈ Ioo a c) : Ioo a c ∈ 𝓝[≤] b 
goal: Set.Ioo a c ∈ 𝓝[≤] b

full_name: Ico_mem_nhdsWithin_Iic
code: theorem Ico_mem_nhdsWithin_Iic (H : b ∈ Ioo a c) : Ico a c ∈ 𝓝[≤] b 
goal: Set.Ico a c ∈ 𝓝[≤] b

full_name: Ioc_mem_nhdsWithin_Iic
code: theorem Ioc_mem_nhdsWithin_Iic (H : b ∈ Ioc a c) : Ioc a c ∈ 𝓝[≤] b 
goal: Set.Ioc a c ∈ 𝓝[≤] b

full_name: Icc_mem_nhdsWithin_Iic
code: theorem Icc_mem_nhdsWithin_Iic (H : b ∈ Ioc a c) : Icc a c ∈ 𝓝[≤] b 
goal: Set.Icc a c ∈ 𝓝[≤] b

full_name: Icc_mem_nhdsWithin_Iic'
code: theorem Icc_mem_nhdsWithin_Iic' (H : a < b) : Icc a b ∈ 𝓝[≤] b 
goal: Set.Icc a b ∈ 𝓝[≤] b

full_name: nhdsWithin_Icc_eq_nhdsWithin_Iic
code: @[simp]
theorem nhdsWithin_Icc_eq_nhdsWithin_Iic (h : a < b) : 𝓝[Icc a b] b = 𝓝[≤] b 
goal: 𝓝[Set.Icc a b] b = 𝓝[≤] b

full_name: nhdsWithin_Ioc_eq_nhdsWithin_Iic
code: @[simp]
theorem nhdsWithin_Ioc_eq_nhdsWithin_Iic (h : a < b) : 𝓝[Ioc a b] b = 𝓝[≤] b 
goal: 𝓝[Set.Ioc a b] b = 𝓝[≤] b

full_name: continuousWithinAt_Icc_iff_Iic
code: @[simp]
theorem continuousWithinAt_Icc_iff_Iic (h : a < b) :
    ContinuousWithinAt f (Icc a b) b ↔ ContinuousWithinAt f (Iic b) b 
goal: ContinuousWithinAt f (Set.Icc a b) b ↔ ContinuousWithinAt f (Set.Iic b) b

full_name: continuousWithinAt_Ioc_iff_Iic
code: @[simp]
theorem continuousWithinAt_Ioc_iff_Iic (h : a < b) :
    ContinuousWithinAt f (Ioc a b) b ↔ ContinuousWithinAt f (Iic b) b 
goal: ContinuousWithinAt f (Set.Ioc a b) b ↔ ContinuousWithinAt f (Set.Iic b) b

full_name: isClosed_Ici
code: theorem isClosed_Ici {a : α} : IsClosed (Ici a) 
goal: IsClosed (Set.Ici a)

full_name: ClosedIciTopology.isClosed_ge'
code: @[deprecated (since := "2024-02-15")]
lemma ClosedIciTopology.isClosed_ge' (a : α) : IsClosed {x | a ≤ x} 
goal: IsClosed {x | a ≤ x}

full_name: instClosedIicTopologyOrderDual
code: instance : ClosedIicTopology αᵒᵈ 
goal: ClosedIicTopology αᵒᵈ

full_name: closure_Ici
code: @[simp]
theorem closure_Ici (a : α) : closure (Ici a) = Ici a 
goal: closure (Set.Ici a) = Set.Ici a

full_name: ge_of_tendsto_of_frequently
code: lemma ge_of_tendsto_of_frequently {x : Filter β} (lim : Tendsto f x (𝓝 a))
    (h : ∃ᶠ c in x, b ≤ f c) : b ≤ a 
goal: b ≤ a

full_name: ge_of_tendsto
code: theorem ge_of_tendsto {x : Filter β} [NeBot x] (lim : Tendsto f x (𝓝 a))
    (h : ∀ᶠ c in x, b ≤ f c) : b ≤ a 
goal: b ≤ a

full_name: ge_of_tendsto'
code: theorem ge_of_tendsto' {x : Filter β} [NeBot x] (lim : Tendsto f x (𝓝 a))
    (h : ∀ c, b ≤ f c) : b ≤ a 
goal: b ≤ a

full_name: lowerBounds_closure
code: @[simp] lemma lowerBounds_closure (s : Set α) : lowerBounds (closure s : Set α) = lowerBounds s 
goal: lowerBounds (closure s) = lowerBounds s

full_name: bddBelow_closure
code: @[simp] lemma bddBelow_closure : BddBelow (closure s) ↔ BddBelow s 
goal: BddBelow (closure s) ↔ BddBelow s

full_name: disjoint_nhds_atTop_iff
code: @[simp]
theorem disjoint_nhds_atTop_iff : Disjoint (𝓝 a) atTop ↔ ¬IsTop a 
goal: Disjoint (𝓝 a) Filter.atTop ↔ ¬IsTop a

full_name: disjoint_nhds_atTop
code: theorem disjoint_nhds_atTop (a : α) : Disjoint (𝓝 a) atTop 
goal: Disjoint (𝓝 a) Filter.atTop

full_name: inf_nhds_atTop
code: @[simp]
theorem inf_nhds_atTop (a : α) : 𝓝 a ⊓ atTop = ⊥ 
goal: 𝓝 a ⊓ Filter.atTop = ⊥

full_name: not_tendsto_nhds_of_tendsto_atTop
code: theorem not_tendsto_nhds_of_tendsto_atTop (hf : Tendsto f l atTop) (a : α) : ¬Tendsto f l (𝓝 a) 
goal: ¬Filter.Tendsto f l (𝓝 a)

full_name: not_tendsto_atTop_of_tendsto_nhds
code: theorem not_tendsto_atTop_of_tendsto_nhds (hf : Tendsto f l (𝓝 a)) : ¬Tendsto f l atTop 
goal: ¬Filter.Tendsto f l Filter.atTop

full_name: isOpen_Iio
code: theorem isOpen_Iio : IsOpen (Iio a) 
goal: IsOpen (Set.Iio a)

full_name: interior_Iio
code: @[simp] theorem interior_Iio : interior (Iio a) = Iio a 
goal: interior (Set.Iio a) = Set.Iio a

full_name: Iio_mem_nhds
code: theorem Iio_mem_nhds (h : a < b) : Iio b ∈ 𝓝 a 
goal: Set.Iio b ∈ 𝓝 a

full_name: eventually_lt_nhds
code: theorem eventually_lt_nhds (hab : a < b) : ∀ᶠ x in 𝓝 a, x < b 
goal: ∀ᶠ (x : α) in 𝓝 a, x < b

full_name: Iic_mem_nhds
code: theorem Iic_mem_nhds (h : a < b) : Iic b ∈ 𝓝 a 
goal: Set.Iic b ∈ 𝓝 a

full_name: eventually_le_nhds
code: theorem eventually_le_nhds (hab : a < b) : ∀ᶠ x in 𝓝 a, x ≤ b 
goal: ∀ᶠ (x : α) in 𝓝 a, x ≤ b

full_name: eventually_lt_of_tendsto_lt
code: theorem eventually_lt_of_tendsto_lt {l : Filter γ} {f : γ → α} {u v : α} (hv : v < u)
    (h : Filter.Tendsto f l (𝓝 v)) : ∀ᶠ a in l, f a < u 
goal: ∀ᶠ (a : γ) in l, f a < u

full_name: eventually_le_of_tendsto_lt
code: theorem eventually_le_of_tendsto_lt {l : Filter γ} {f : γ → α} {u v : α} (hv : v < u)
    (h : Tendsto f l (𝓝 v)) : ∀ᶠ a in l, f a ≤ u 
goal: ∀ᶠ (a : γ) in l, f a ≤ u

full_name: Dense.exists_lt
code: protected theorem Dense.exists_lt [NoMinOrder α] {s : Set α} (hs : Dense s) (x : α) :
    ∃ y ∈ s, y < x 
goal: ∃ y ∈ s, y < x

full_name: Dense.exists_le
code: protected theorem Dense.exists_le [NoMinOrder α] {s : Set α} (hs : Dense s) (x : α) :
    ∃ y ∈ s, y ≤ x 
goal: ∃ y ∈ s, y ≤ x

full_name: Dense.exists_le'
code: theorem Dense.exists_le' {s : Set α} (hs : Dense s) (hbot : ∀ x, IsBot x → x ∈ s) (x : α) :
    ∃ y ∈ s, y ≤ x 
goal: ∃ y ∈ s, y ≤ x

full_name: Ioo_mem_nhdsWithin_Ioi
code: theorem Ioo_mem_nhdsWithin_Ioi {a b c : α} (H : b ∈ Ico a c) : Ioo a c ∈ 𝓝[>] b 
goal: Set.Ioo a c ∈ 𝓝[>] b

full_name: Ioo_mem_nhdsWithin_Ioi'
code: theorem Ioo_mem_nhdsWithin_Ioi' {a b : α} (H : a < b) : Ioo a b ∈ 𝓝[>] a 
goal: Set.Ioo a b ∈ 𝓝[>] a

full_name: CovBy.nhdsWithin_Ioi
code: theorem CovBy.nhdsWithin_Ioi {a b : α} (h : a ⋖ b) : 𝓝[>] a = ⊥ 
goal: 𝓝[>] a = ⊥

full_name: Ioc_mem_nhdsWithin_Ioi
code: theorem Ioc_mem_nhdsWithin_Ioi {a b c : α} (H : b ∈ Ico a c) : Ioc a c ∈ 𝓝[>] b 
goal: Set.Ioc a c ∈ 𝓝[>] b

full_name: Ioc_mem_nhdsWithin_Ioi'
code: theorem Ioc_mem_nhdsWithin_Ioi' {a b : α} (H : a < b) : Ioc a b ∈ 𝓝[>] a 
goal: Set.Ioc a b ∈ 𝓝[>] a

full_name: Ico_mem_nhdsWithin_Ioi
code: theorem Ico_mem_nhdsWithin_Ioi {a b c : α} (H : b ∈ Ico a c) : Ico a c ∈ 𝓝[>] b 
goal: Set.Ico a c ∈ 𝓝[>] b

full_name: Ico_mem_nhdsWithin_Ioi'
code: theorem Ico_mem_nhdsWithin_Ioi' {a b : α} (H : a < b) : Ico a b ∈ 𝓝[>] a 
goal: Set.Ico a b ∈ 𝓝[>] a

full_name: Icc_mem_nhdsWithin_Ioi
code: theorem Icc_mem_nhdsWithin_Ioi {a b c : α} (H : b ∈ Ico a c) : Icc a c ∈ 𝓝[>] b 
goal: Set.Icc a c ∈ 𝓝[>] b

full_name: Icc_mem_nhdsWithin_Ioi'
code: theorem Icc_mem_nhdsWithin_Ioi' {a b : α} (H : a < b) : Icc a b ∈ 𝓝[>] a 
goal: Set.Icc a b ∈ 𝓝[>] a

full_name: nhdsWithin_Ioc_eq_nhdsWithin_Ioi
code: @[simp]
theorem nhdsWithin_Ioc_eq_nhdsWithin_Ioi {a b : α} (h : a < b) : 𝓝[Ioc a b] a = 𝓝[>] a 
goal: 𝓝[Set.Ioc a b] a = 𝓝[>] a

full_name: nhdsWithin_Ioo_eq_nhdsWithin_Ioi
code: @[simp]
theorem nhdsWithin_Ioo_eq_nhdsWithin_Ioi {a b : α} (h : a < b) : 𝓝[Ioo a b] a = 𝓝[>] a 
goal: 𝓝[Set.Ioo a b] a = 𝓝[>] a

full_name: continuousWithinAt_Ioc_iff_Ioi
code: @[simp]
theorem continuousWithinAt_Ioc_iff_Ioi (h : a < b) :
    ContinuousWithinAt f (Ioc a b) a ↔ ContinuousWithinAt f (Ioi a) a 
goal: ContinuousWithinAt f (Set.Ioc a b) a ↔ ContinuousWithinAt f (Set.Ioi a) a

full_name: continuousWithinAt_Ioo_iff_Ioi
code: @[simp]
theorem continuousWithinAt_Ioo_iff_Ioi (h : a < b) :
    ContinuousWithinAt f (Ioo a b) a ↔ ContinuousWithinAt f (Ioi a) a 
goal: ContinuousWithinAt f (Set.Ioo a b) a ↔ ContinuousWithinAt f (Set.Ioi a) a

full_name: Ico_mem_nhdsWithin_Ici'
code: theorem Ico_mem_nhdsWithin_Ici' (H : a < b) : Ico a b ∈ 𝓝[≥] a 
goal: Set.Ico a b ∈ 𝓝[≥] a

full_name: Ico_mem_nhdsWithin_Ici
code: theorem Ico_mem_nhdsWithin_Ici (H : b ∈ Ico a c) : Ico a c ∈ 𝓝[≥] b 
goal: Set.Ico a c ∈ 𝓝[≥] b

full_name: Ioo_mem_nhdsWithin_Ici
code: theorem Ioo_mem_nhdsWithin_Ici (H : b ∈ Ioo a c) : Ioo a c ∈ 𝓝[≥] b 
goal: Set.Ioo a c ∈ 𝓝[≥] b

full_name: Ioc_mem_nhdsWithin_Ici
code: theorem Ioc_mem_nhdsWithin_Ici (H : b ∈ Ioo a c) : Ioc a c ∈ 𝓝[≥] b 
goal: Set.Ioc a c ∈ 𝓝[≥] b

full_name: Icc_mem_nhdsWithin_Ici
code: theorem Icc_mem_nhdsWithin_Ici (H : b ∈ Ico a c) : Icc a c ∈ 𝓝[≥] b 
goal: Set.Icc a c ∈ 𝓝[≥] b

full_name: Icc_mem_nhdsWithin_Ici'
code: theorem Icc_mem_nhdsWithin_Ici' (H : a < b) : Icc a b ∈ 𝓝[≥] a 
goal: Set.Icc a b ∈ 𝓝[≥] a

full_name: nhdsWithin_Icc_eq_nhdsWithin_Ici
code: @[simp]
theorem nhdsWithin_Icc_eq_nhdsWithin_Ici (h : a < b) : 𝓝[Icc a b] a = 𝓝[≥] a 
goal: 𝓝[Set.Icc a b] a = 𝓝[≥] a

full_name: nhdsWithin_Ico_eq_nhdsWithin_Ici
code: @[simp]
theorem nhdsWithin_Ico_eq_nhdsWithin_Ici (h : a < b) : 𝓝[Ico a b] a = 𝓝[≥] a 
goal: 𝓝[Set.Ico a b] a = 𝓝[≥] a

full_name: continuousWithinAt_Icc_iff_Ici
code: @[simp]
theorem continuousWithinAt_Icc_iff_Ici (h : a < b) :
    ContinuousWithinAt f (Icc a b) a ↔ ContinuousWithinAt f (Ici a) a 
goal: ContinuousWithinAt f (Set.Icc a b) a ↔ ContinuousWithinAt f (Set.Ici a) a

full_name: continuousWithinAt_Ico_iff_Ici
code: @[simp]
theorem continuousWithinAt_Ico_iff_Ici (h : a < b) :
    ContinuousWithinAt f (Ico a b) a ↔ ContinuousWithinAt f (Ici a) a 
goal: ContinuousWithinAt f (Set.Ico a b) a ↔ ContinuousWithinAt f (Set.Ici a) a

full_name: Subtype.instOrderClosedTopology
code: instance {p : α → Prop} : OrderClosedTopology (Subtype p) 
goal: OrderClosedTopology (Subtype p)

full_name: isClosed_le_prod
code: theorem isClosed_le_prod : IsClosed { p : α × α | p.1 ≤ p.2 } 
goal: IsClosed {p | p.1 ≤ p.2}

full_name: isClosed_le
code: theorem isClosed_le [TopologicalSpace β] {f g : β → α} (hf : Continuous f) (hg : Continuous g) :
    IsClosed { b | f b ≤ g b } 
goal: IsClosed {b | f b ≤ g b}

full_name: instClosedIicTopology
code: instance : ClosedIicTopology α 
goal: ClosedIicTopology α

full_name: instClosedIciTopology
code: instance : ClosedIciTopology α 
goal: ClosedIciTopology α

full_name: instOrderClosedTopologyOrderDual
code: instance : OrderClosedTopology αᵒᵈ 
goal: OrderClosedTopology αᵒᵈ

full_name: isClosed_Icc
code: theorem isClosed_Icc {a b : α} : IsClosed (Icc a b) 
goal: IsClosed (Set.Icc a b)

full_name: closure_Icc
code: @[simp]
theorem closure_Icc (a b : α) : closure (Icc a b) = Icc a b 
goal: closure (Set.Icc a b) = Set.Icc a b

full_name: le_of_tendsto_of_tendsto
code: theorem le_of_tendsto_of_tendsto {f g : β → α} {b : Filter β} {a₁ a₂ : α} [NeBot b]
    (hf : Tendsto f b (𝓝 a₁)) (hg : Tendsto g b (𝓝 a₂)) (h : f ≤ᶠ[b] g) : a₁ ≤ a₂ 
goal: a₁ ≤ a₂

full_name: le_of_tendsto_of_tendsto'
code: theorem le_of_tendsto_of_tendsto' {f g : β → α} {b : Filter β} {a₁ a₂ : α} [NeBot b]
    (hf : Tendsto f b (𝓝 a₁)) (hg : Tendsto g b (𝓝 a₂)) (h : ∀ x, f x ≤ g x) : a₁ ≤ a₂ 
goal: a₁ ≤ a₂

full_name: closure_le_eq
code: @[simp]
theorem closure_le_eq [TopologicalSpace β] {f g : β → α} (hf : Continuous f) (hg : Continuous g) :
    closure { b | f b ≤ g b } = { b | f b ≤ g b } 
goal: closure {b | f b ≤ g b} = {b | f b ≤ g b}

full_name: closure_lt_subset_le
code: theorem closure_lt_subset_le [TopologicalSpace β] {f g : β → α} (hf : Continuous f)
    (hg : Continuous g) : closure { b | f b < g b } ⊆ { b | f b ≤ g b } 
goal: closure {b | f b < g b} ⊆ {b | f b ≤ g b}

full_name: ContinuousWithinAt.closure_le
code: theorem ContinuousWithinAt.closure_le [TopologicalSpace β] {f g : β → α} {s : Set β} {x : β}
    (hx : x ∈ closure s) (hf : ContinuousWithinAt f s x) (hg : ContinuousWithinAt g s x)
    (h : ∀ y ∈ s, f y ≤ g y) : f x ≤ g x 
goal: f x ≤ g x

full_name: IsClosed.isClosed_le
code: /-- If `s` is a closed set and two functions `f` and `g` are continuous on `s`,
then the set `{x ∈ s | f x ≤ g x}` is a closed set. -/
theorem IsClosed.isClosed_le [TopologicalSpace β] {f g : β → α} {s : Set β} (hs : IsClosed s)
    (hf : ContinuousOn f s) (hg : ContinuousOn g s) : IsClosed ({ x ∈ s | f x ≤ g x }) 
goal: IsClosed {x | x ∈ s ∧ f x ≤ g x}

full_name: le_on_closure
code: theorem le_on_closure [TopologicalSpace β] {f g : β → α} {s : Set β} (h : ∀ x ∈ s, f x ≤ g x)
    (hf : ContinuousOn f (closure s)) (hg : ContinuousOn g (closure s)) ⦃x⦄ (hx : x ∈ closure s) :
    f x ≤ g x 
goal: f x ≤ g x

full_name: IsClosed.epigraph
code: theorem IsClosed.epigraph [TopologicalSpace β] {f : β → α} {s : Set β} (hs : IsClosed s)
    (hf : ContinuousOn f s) : IsClosed { p : β × α | p.1 ∈ s ∧ f p.1 ≤ p.2 } 
goal: IsClosed {p | p.1 ∈ s ∧ f p.1 ≤ p.2}

full_name: IsClosed.hypograph
code: theorem IsClosed.hypograph [TopologicalSpace β] {f : β → α} {s : Set β} (hs : IsClosed s)
    (hf : ContinuousOn f s) : IsClosed { p : β × α | p.1 ∈ s ∧ p.2 ≤ f p.1 } 
goal: IsClosed {p | p.1 ∈ s ∧ p.2 ≤ f p.1}

full_name: OrderClosedTopology.to_t2Space
code: instance (priority := 90) OrderClosedTopology.to_t2Space : T2Space α 
goal: T2Space α

full_name: isOpen_lt
code: theorem isOpen_lt [TopologicalSpace β] {f g : β → α} (hf : Continuous f) (hg : Continuous g) :
    IsOpen { b | f b < g b } 
goal: IsOpen {b | f b < g b}

full_name: isOpen_lt_prod
code: theorem isOpen_lt_prod : IsOpen { p : α × α | p.1 < p.2 } 
goal: IsOpen {p | p.1 < p.2}

full_name: isOpen_Ioo
code: theorem isOpen_Ioo : IsOpen (Ioo a b) 
goal: IsOpen (Set.Ioo a b)

full_name: interior_Ioo
code: @[simp]
theorem interior_Ioo : interior (Ioo a b) = Ioo a b 
goal: interior (Set.Ioo a b) = Set.Ioo a b

full_name: Ioo_subset_closure_interior
code: theorem Ioo_subset_closure_interior : Ioo a b ⊆ closure (interior (Ioo a b)) 
goal: Set.Ioo a b ⊆ closure (interior (Set.Ioo a b))

full_name: Ioo_mem_nhds
code: theorem Ioo_mem_nhds {a b x : α} (ha : a < x) (hb : x < b) : Ioo a b ∈ 𝓝 x 
goal: Set.Ioo a b ∈ 𝓝 x

full_name: Ioc_mem_nhds
code: theorem Ioc_mem_nhds {a b x : α} (ha : a < x) (hb : x < b) : Ioc a b ∈ 𝓝 x 
goal: Set.Ioc a b ∈ 𝓝 x

full_name: Ico_mem_nhds
code: theorem Ico_mem_nhds {a b x : α} (ha : a < x) (hb : x < b) : Ico a b ∈ 𝓝 x 
goal: Set.Ico a b ∈ 𝓝 x

full_name: Icc_mem_nhds
code: theorem Icc_mem_nhds {a b x : α} (ha : a < x) (hb : x < b) : Icc a b ∈ 𝓝 x 
goal: Set.Icc a b ∈ 𝓝 x

full_name: lt_subset_interior_le
code: theorem lt_subset_interior_le (hf : Continuous f) (hg : Continuous g) :
    { b | f b < g b } ⊆ interior { b | f b ≤ g b } 
goal: {b | f b < g b} ⊆ interior {b | f b ≤ g b}

full_name: frontier_le_subset_eq
code: theorem frontier_le_subset_eq (hf : Continuous f) (hg : Continuous g) :
    frontier { b | f b ≤ g b } ⊆ { b | f b = g b } 
goal: frontier {b | f b ≤ g b} ⊆ {b | f b = g b}

full_name: frontier_Iic_subset
code: theorem frontier_Iic_subset (a : α) : frontier (Iic a) ⊆ {a} 
goal: frontier (Set.Iic a) ⊆ {a}

full_name: frontier_Ici_subset
code: theorem frontier_Ici_subset (a : α) : frontier (Ici a) ⊆ {a} 
goal: frontier (Set.Ici a) ⊆ {a}

full_name: frontier_lt_subset_eq
code: theorem frontier_lt_subset_eq (hf : Continuous f) (hg : Continuous g) :
    frontier { b | f b < g b } ⊆ { b | f b = g b } 
goal: frontier {b | f b < g b} ⊆ {b | f b = g b}

full_name: continuous_if_le
code: theorem continuous_if_le [TopologicalSpace γ] [∀ x, Decidable (f x ≤ g x)] {f' g' : β → γ}
    (hf : Continuous f) (hg : Continuous g) (hf' : ContinuousOn f' { x | f x ≤ g x })
    (hg' : ContinuousOn g' { x | g x ≤ f x }) (hfg : ∀ x, f x = g x → f' x = g' x) :
    Continuous fun x => if f x ≤ g x then f' x else g' x 
goal: Continuous fun x => if f x ≤ g x then f' x else g' x

full_name: Continuous.if_le
code: theorem Continuous.if_le [TopologicalSpace γ] [∀ x, Decidable (f x ≤ g x)] {f' g' : β → γ}
    (hf' : Continuous f') (hg' : Continuous g') (hf : Continuous f) (hg : Continuous g)
    (hfg : ∀ x, f x = g x → f' x = g' x) : Continuous fun x => if f x ≤ g x then f' x else g' x 
goal: Continuous fun x => if f x ≤ g x then f' x else g' x

full_name: Filter.Tendsto.eventually_lt
code: theorem Filter.Tendsto.eventually_lt {l : Filter γ} {f g : γ → α} {y z : α} (hf : Tendsto f l (𝓝 y))
    (hg : Tendsto g l (𝓝 z)) (hyz : y < z) : ∀ᶠ x in l, f x < g x 
goal: ∀ᶠ (x : γ) in l, f x < g x

full_name: ContinuousAt.eventually_lt
code: nonrec theorem ContinuousAt.eventually_lt {x₀ : β} (hf : ContinuousAt f x₀) (hg : ContinuousAt g x₀)
    (hfg : f x₀ < g x₀) : ∀ᶠ x in 𝓝 x₀, f x < g x 
goal: ∀ᶠ (x : β) in 𝓝 x₀, f x < g x

full_name: Continuous.min
code: @[continuity, fun_prop]
protected theorem Continuous.min (hf : Continuous f) (hg : Continuous g) :
    Continuous fun b => min (f b) (g b) 
goal: Continuous fun b => min (f b) (g b)

full_name: Continuous.max
code: @[continuity, fun_prop]
protected theorem Continuous.max (hf : Continuous f) (hg : Continuous g) :
    Continuous fun b => max (f b) (g b) 
goal: Continuous fun b => max (f b) (g b)

full_name: continuous_min
code: theorem continuous_min : Continuous fun p : α × α => min p.1 p.2 
goal: Continuous fun p => min p.1 p.2

full_name: continuous_max
code: theorem continuous_max : Continuous fun p : α × α => max p.1 p.2 
goal: Continuous fun p => max p.1 p.2

full_name: Filter.Tendsto.max
code: protected theorem Filter.Tendsto.max {b : Filter β} {a₁ a₂ : α} (hf : Tendsto f b (𝓝 a₁))
    (hg : Tendsto g b (𝓝 a₂)) : Tendsto (fun b => max (f b) (g b)) b (𝓝 (max a₁ a₂)) 
goal: Filter.Tendsto (fun b => max (f b) (g b)) b (𝓝 (max a₁ a₂))

full_name: Filter.Tendsto.min
code: protected theorem Filter.Tendsto.min {b : Filter β} {a₁ a₂ : α} (hf : Tendsto f b (𝓝 a₁))
    (hg : Tendsto g b (𝓝 a₂)) : Tendsto (fun b => min (f b) (g b)) b (𝓝 (min a₁ a₂)) 
goal: Filter.Tendsto (fun b => min (f b) (g b)) b (𝓝 (min a₁ a₂))

full_name: Filter.Tendsto.max_right
code: protected theorem Filter.Tendsto.max_right {l : Filter β} {a : α} (h : Tendsto f l (𝓝 a)) :
    Tendsto (fun i => max a (f i)) l (𝓝 a) 
goal: Filter.Tendsto (fun i => max a (f i)) l (𝓝 a)

full_name: Filter.Tendsto.max_left
code: protected theorem Filter.Tendsto.max_left {l : Filter β} {a : α} (h : Tendsto f l (𝓝 a)) :
    Tendsto (fun i => max (f i) a) l (𝓝 a) 
goal: Filter.Tendsto (fun i => max (f i) a) l (𝓝 a)

full_name: Filter.tendsto_nhds_max_right
code: theorem Filter.tendsto_nhds_max_right {l : Filter β} {a : α} (h : Tendsto f l (𝓝[>] a)) :
    Tendsto (fun i => max a (f i)) l (𝓝[>] a) 
goal: Filter.Tendsto (fun i => max a (f i)) l (𝓝[>] a)

full_name: Filter.tendsto_nhds_max_left
code: theorem Filter.tendsto_nhds_max_left {l : Filter β} {a : α} (h : Tendsto f l (𝓝[>] a)) :
    Tendsto (fun i => max (f i) a) l (𝓝[>] a) 
goal: Filter.Tendsto (fun i => max (f i) a) l (𝓝[>] a)

full_name: Filter.Tendsto.min_right
code: theorem Filter.Tendsto.min_right {l : Filter β} {a : α} (h : Tendsto f l (𝓝 a)) :
    Tendsto (fun i => min a (f i)) l (𝓝 a) 
goal: Filter.Tendsto (fun i => min a (f i)) l (𝓝 a)

full_name: Filter.Tendsto.min_left
code: theorem Filter.Tendsto.min_left {l : Filter β} {a : α} (h : Tendsto f l (𝓝 a)) :
    Tendsto (fun i => min (f i) a) l (𝓝 a) 
goal: Filter.Tendsto (fun i => min (f i) a) l (𝓝 a)

full_name: Filter.tendsto_nhds_min_right
code: theorem Filter.tendsto_nhds_min_right {l : Filter β} {a : α} (h : Tendsto f l (𝓝[<] a)) :
    Tendsto (fun i => min a (f i)) l (𝓝[<] a) 
goal: Filter.Tendsto (fun i => min a (f i)) l (𝓝[<] a)

full_name: Filter.tendsto_nhds_min_left
code: theorem Filter.tendsto_nhds_min_left {l : Filter β} {a : α} (h : Tendsto f l (𝓝[<] a)) :
    Tendsto (fun i => min (f i) a) l (𝓝[<] a) 
goal: Filter.Tendsto (fun i => min (f i) a) l (𝓝[<] a)

full_name: Dense.exists_between
code: theorem Dense.exists_between [DenselyOrdered α] {s : Set α} (hs : Dense s) {x y : α} (h : x < y) :
    ∃ z ∈ s, z ∈ Ioo x y 
goal: ∃ z ∈ s, z ∈ Set.Ioo x y

full_name: Dense.Ioi_eq_biUnion
code: theorem Dense.Ioi_eq_biUnion [DenselyOrdered α] {s : Set α} (hs : Dense s) (x : α) :
    Ioi x = ⋃ y ∈ s ∩ Ioi x, Ioi y 
goal: Set.Ioi x = ⋃ y ∈ s ∩ Set.Ioi x, Set.Ioi y

full_name: Dense.Iio_eq_biUnion
code: theorem Dense.Iio_eq_biUnion [DenselyOrdered α] {s : Set α} (hs : Dense s) (x : α) :
    Iio x = ⋃ y ∈ s ∩ Iio x, Iio y 
goal: Set.Iio x = ⋃ y ∈ s ∩ Set.Iio x, Set.Iio y

full_name: instOrderClosedTopologyProd
code: instance [Preorder α] [TopologicalSpace α] [OrderClosedTopology α] [Preorder β] [TopologicalSpace β]
    [OrderClosedTopology β] : OrderClosedTopology (α × β) 
goal: OrderClosedTopology (α × β)

full_name: instOrderClosedTopologyForall
code: instance {ι : Type*} {α : ι → Type*} [∀ i, Preorder (α i)] [∀ i, TopologicalSpace (α i)]
    [∀ i, OrderClosedTopology (α i)] : OrderClosedTopology (∀ i, α i) 
goal: OrderClosedTopology ((i : ι) → α i)

full_name: Pi.orderClosedTopology'
code: instance Pi.orderClosedTopology' [Preorder β] [TopologicalSpace β] [OrderClosedTopology β] :
    OrderClosedTopology (α → β) 
goal: OrderClosedTopology (α → β)