File: Mathlib/Topology/Order/Basic.lean

full_name: OrderTopology.topology_eq_generate_intervals
code: /-- The order topology on an ordered type is the topology generated by open intervals. We register
it on a preorder, but it is mostly interesting in linear orders, where it is also order-closed.
We define it as a mixin. If you want to introduce the order topology on a preorder, use
`Preorder.topology`. -/
class OrderTopology (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  /-- The topology is generated by open intervals `Set.Ioi _` and `Set.Iio _`. -/
  topology_eq_generate_intervals : t = generateFrom { s | ∃ a, s = Ioi a ∨ s = Iio a }
goal: t = TopologicalSpace.generateFrom {s | ∃ a, s = Set.Ioi a ∨ s = Set.Iio a}

full_name: OrderTopology
code: /-- The order topology on an ordered type is the topology generated by open intervals. We register
it on a preorder, but it is mostly interesting in linear orders, where it is also order-closed.
We define it as a mixin. If you want to introduce the order topology on a preorder, use
`Preorder.topology`. -/
class OrderTopology (α : Type*) [t : TopologicalSpace α] [Preorder α] : Prop where
  /-- The topology is generated by open intervals `Set.Ioi _` and `Set.Iio _`. -/
  topology_eq_generate_intervals : t = generateFrom { s | ∃ a, s = Ioi a ∨ s = Iio a }
goal: Prop

full_name: Preorder.topology
code: /-- (Order) topology on a partial order `α` generated by the subbase of open intervals
`(a, ∞) = { x ∣ a < x }, (-∞ , b) = {x ∣ x < b}` for all `a, b` in `α`. We do not register it as an
instance as many ordered sets are already endowed with the same topology, most often in a non-defeq
way though. Register as a local instance when necessary. -/
def Preorder.topology (α : Type*) [Preorder α] : TopologicalSpace α 
goal: TopologicalSpace α

full_name: instOrderTopologyOrderDual
code: instance [t : OrderTopology α] : OrderTopology αᵒᵈ 
goal: OrderTopology αᵒᵈ

full_name: isOpen_iff_generate_intervals
code: theorem isOpen_iff_generate_intervals [t : OrderTopology α] {s : Set α} :
    IsOpen s ↔ GenerateOpen { s | ∃ a, s = Ioi a ∨ s = Iio a } s 
goal: IsOpen s ↔ TopologicalSpace.GenerateOpen {s | ∃ a, s = Set.Ioi a ∨ s = Set.Iio a} s

full_name: isOpen_lt'
code: theorem isOpen_lt' [OrderTopology α] (a : α) : IsOpen { b : α | a < b } 
goal: IsOpen {b | a < b}

full_name: isOpen_gt'
code: theorem isOpen_gt' [OrderTopology α] (a : α) : IsOpen { b : α | b < a } 
goal: IsOpen {b | b < a}

full_name: lt_mem_nhds
code: theorem lt_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 b, a < x 
goal: ∀ᶠ (x : α) in 𝓝 b, a < x

full_name: le_mem_nhds
code: theorem le_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 b, a ≤ x 
goal: ∀ᶠ (x : α) in 𝓝 b, a ≤ x

full_name: gt_mem_nhds
code: theorem gt_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 a, x < b 
goal: ∀ᶠ (x : α) in 𝓝 a, x < b

full_name: ge_mem_nhds
code: theorem ge_mem_nhds [OrderTopology α] {a b : α} (h : a < b) : ∀ᶠ x in 𝓝 a, x ≤ b 
goal: ∀ᶠ (x : α) in 𝓝 a, x ≤ b

full_name: nhds_eq_order
code: theorem nhds_eq_order [OrderTopology α] (a : α) :
    𝓝 a = (⨅ b ∈ Iio a, 𝓟 (Ioi b)) ⊓ ⨅ b ∈ Ioi a, 𝓟 (Iio b) 
goal: 𝓝 a = (⨅ b ∈ Set.Iio a, 𝓟 (Set.Ioi b)) ⊓ ⨅ b ∈ Set.Ioi a, 𝓟 (Set.Iio b)

full_name: tendsto_order
code: theorem tendsto_order [OrderTopology α] {f : β → α} {a : α} {x : Filter β} :
    Tendsto f x (𝓝 a) ↔ (∀ a' < a, ∀ᶠ b in x, a' < f b) ∧ ∀ a' > a, ∀ᶠ b in x, f b < a' 
goal: Filter.Tendsto f x (𝓝 a) ↔ (∀ a' < a, ∀ᶠ (b : β) in x, a' < f b) ∧ ∀ a' > a, ∀ᶠ (b : β) in x, f b < a'

full_name: tendstoIccClassNhds
code: instance tendstoIccClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Icc (𝓝 a) (𝓝 a) 
goal: Filter.TendstoIxxClass Set.Icc (𝓝 a) (𝓝 a)

full_name: tendstoIcoClassNhds
code: instance tendstoIcoClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Ico (𝓝 a) (𝓝 a) 
goal: Filter.TendstoIxxClass Set.Ico (𝓝 a) (𝓝 a)

full_name: tendstoIocClassNhds
code: instance tendstoIocClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Ioc (𝓝 a) (𝓝 a) 
goal: Filter.TendstoIxxClass Set.Ioc (𝓝 a) (𝓝 a)

full_name: tendstoIooClassNhds
code: instance tendstoIooClassNhds [OrderTopology α] (a : α) : TendstoIxxClass Ioo (𝓝 a) (𝓝 a) 
goal: Filter.TendstoIxxClass Set.Ioo (𝓝 a) (𝓝 a)

full_name: tendsto_of_tendsto_of_tendsto_of_le_of_le'
code: /-- **Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold eventually for the filter. -/
theorem tendsto_of_tendsto_of_tendsto_of_le_of_le' [OrderTopology α] {f g h : β → α} {b : Filter β}
    {a : α} (hg : Tendsto g b (𝓝 a)) (hh : Tendsto h b (𝓝 a)) (hgf : ∀ᶠ b in b, g b ≤ f b)
    (hfh : ∀ᶠ b in b, f b ≤ h b) : Tendsto f b (𝓝 a) 
goal: Filter.Tendsto f b (𝓝 a)

full_name: tendsto_of_tendsto_of_tendsto_of_le_of_le
code: /-- **Squeeze theorem** (also known as **sandwich theorem**). This version assumes that inequalities
hold everywhere. -/
theorem tendsto_of_tendsto_of_tendsto_of_le_of_le [OrderTopology α] {f g h : β → α} {b : Filter β}
    {a : α} (hg : Tendsto g b (𝓝 a)) (hh : Tendsto h b (𝓝 a)) (hgf : g ≤ f) (hfh : f ≤ h) :
    Tendsto f b (𝓝 a) 
goal: Filter.Tendsto f b (𝓝 a)

full_name: nhds_order_unbounded
code: theorem nhds_order_unbounded [OrderTopology α] {a : α} (hu : ∃ u, a < u) (hl : ∃ l, l < a) :
    𝓝 a = ⨅ (l) (_ : l < a) (u) (_ : a < u), 𝓟 (Ioo l u) 
goal: 𝓝 a = ⨅ l, ⨅ (_ : l < a), ⨅ u, ⨅ (_ : a < u), 𝓟 (Set.Ioo l u)

full_name: tendsto_order_unbounded
code: theorem tendsto_order_unbounded [OrderTopology α] {f : β → α} {a : α} {x : Filter β}
    (hu : ∃ u, a < u) (hl : ∃ l, l < a) (h : ∀ l u, l < a → a < u → ∀ᶠ b in x, l < f b ∧ f b < u) :
    Tendsto f x (𝓝 a) 
goal: Filter.Tendsto f x (𝓝 a)

full_name: tendstoIxxNhdsWithin
code: instance tendstoIxxNhdsWithin {α : Type*} [TopologicalSpace α] (a : α) {s t : Set α}
    {Ixx} [TendstoIxxClass Ixx (𝓝 a) (𝓝 a)] [TendstoIxxClass Ixx (𝓟 s) (𝓟 t)] :
    TendstoIxxClass Ixx (𝓝[s] a) (𝓝[t] a) 
goal: Filter.TendstoIxxClass Ixx (𝓝[s] a) (𝓝[t] a)

full_name: tendstoIccClassNhdsPi
code: instance tendstoIccClassNhdsPi {ι : Type*} {α : ι → Type*} [∀ i, Preorder (α i)]
    [∀ i, TopologicalSpace (α i)] [∀ i, OrderTopology (α i)] (f : ∀ i, α i) :
    TendstoIxxClass Icc (𝓝 f) (𝓝 f) 
goal: Filter.TendstoIxxClass Set.Icc (𝓝 f) (𝓝 f)

full_name: induced_topology_le_preorder
code: theorem induced_topology_le_preorder [Preorder α] [Preorder β] [TopologicalSpace β]
    [OrderTopology β] {f : α → β} (hf : ∀ {x y}, f x < f y ↔ x < y) :
    induced f ‹TopologicalSpace β› ≤ Preorder.topology α 
goal: TopologicalSpace.induced f inst✝ ≤ Preorder.topology α

full_name: induced_topology_eq_preorder
code: theorem induced_topology_eq_preorder [Preorder α] [Preorder β] [TopologicalSpace β]
    [OrderTopology β] {f : α → β} (hf : ∀ {x y}, f x < f y ↔ x < y)
    (H₁ : ∀ {a b x}, b < f a → ¬(b < f x) → ∃ y, y < a ∧ b ≤ f y)
    (H₂ : ∀ {a b x}, f a < b → ¬(f x < b) → ∃ y, a < y ∧ f y ≤ b) :
    induced f ‹TopologicalSpace β› = Preorder.topology α 
goal: TopologicalSpace.induced f inst✝ = Preorder.topology α

full_name: induced_orderTopology'
code: theorem induced_orderTopology' {α : Type u} {β : Type v} [Preorder α] [ta : TopologicalSpace β]
    [Preorder β] [OrderTopology β] (f : α → β) (hf : ∀ {x y}, f x < f y ↔ x < y)
    (H₁ : ∀ {a x}, x < f a → ∃ b < a, x ≤ f b) (H₂ : ∀ {a x}, f a < x → ∃ b > a, f b ≤ x) :
    @OrderTopology _ (induced f ta) _ 
goal: OrderTopology α

full_name: induced_orderTopology
code: theorem induced_orderTopology {α : Type u} {β : Type v} [Preorder α] [ta : TopologicalSpace β]
    [Preorder β] [OrderTopology β] (f : α → β) (hf : ∀ {x y}, f x < f y ↔ x < y)
    (H : ∀ {x y}, x < y → ∃ a, x < f a ∧ f a < y) : @OrderTopology _ (induced f ta) _ 
goal: OrderTopology α

full_name: StrictMono.induced_topology_eq_preorder
code: /-- The topology induced by a strictly monotone function with order-connected range is the preorder
topology. -/
nonrec theorem StrictMono.induced_topology_eq_preorder {α β : Type*} [LinearOrder α]
    [LinearOrder β] [t : TopologicalSpace β] [OrderTopology β] {f : α → β}
    (hf : StrictMono f) (hc : OrdConnected (range f)) : t.induced f = Preorder.topology α 
goal: TopologicalSpace.induced f t = Preorder.topology α

full_name: StrictMono.embedding_of_ordConnected
code: /-- A strictly monotone function between linear orders with order topology is a topological
embedding provided that the range of `f` is order-connected. -/
theorem StrictMono.embedding_of_ordConnected {α β : Type*} [LinearOrder α] [LinearOrder β]
    [TopologicalSpace α] [h : OrderTopology α] [TopologicalSpace β] [OrderTopology β] {f : α → β}
    (hf : StrictMono f) (hc : OrdConnected (range f)) : Embedding f 
goal: Embedding f

full_name: orderTopology_of_ordConnected
code: /-- On a `Set.OrdConnected` subset of a linear order, the order topology for the restriction of the
order is the same as the restriction to the subset of the order topology. -/
instance orderTopology_of_ordConnected {α : Type u} [TopologicalSpace α] [LinearOrder α]
    [OrderTopology α] {t : Set α} [ht : OrdConnected t] : OrderTopology t 
goal: OrderTopology ↑t

full_name: nhdsWithin_Ici_eq''
code: theorem nhdsWithin_Ici_eq'' [TopologicalSpace α] [Preorder α] [OrderTopology α] (a : α) :
    𝓝[≥] a = (⨅ (u) (_ : a < u), 𝓟 (Iio u)) ⊓ 𝓟 (Ici a) 
goal: 𝓝[≥] a = (⨅ u, ⨅ (_ : a < u), 𝓟 (Set.Iio u)) ⊓ 𝓟 (Set.Ici a)

full_name: nhdsWithin_Iic_eq''
code: theorem nhdsWithin_Iic_eq'' [TopologicalSpace α] [Preorder α] [OrderTopology α] (a : α) :
    𝓝[≤] a = (⨅ l < a, 𝓟 (Ioi l)) ⊓ 𝓟 (Iic a) 
goal: 𝓝[≤] a = (⨅ l, ⨅ (_ : l < a), 𝓟 (Set.Ioi l)) ⊓ 𝓟 (Set.Iic a)

full_name: nhdsWithin_Ici_eq'
code: theorem nhdsWithin_Ici_eq' [TopologicalSpace α] [Preorder α] [OrderTopology α] {a : α}
    (ha : ∃ u, a < u) : 𝓝[≥] a = ⨅ (u) (_ : a < u), 𝓟 (Ico a u) 
goal: 𝓝[≥] a = ⨅ u, ⨅ (_ : a < u), 𝓟 (Set.Ico a u)

full_name: nhdsWithin_Iic_eq'
code: theorem nhdsWithin_Iic_eq' [TopologicalSpace α] [Preorder α] [OrderTopology α] {a : α}
    (ha : ∃ l, l < a) : 𝓝[≤] a = ⨅ l < a, 𝓟 (Ioc l a) 
goal: 𝓝[≤] a = ⨅ l, ⨅ (_ : l < a), 𝓟 (Set.Ioc l a)

full_name: nhdsWithin_Ici_basis'
code: theorem nhdsWithin_Ici_basis' [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {a : α}
    (ha : ∃ u, a < u) : (𝓝[≥] a).HasBasis (fun u => a < u) fun u => Ico a u 
goal: (𝓝[≥] a).HasBasis (fun u => a < u) fun u => Set.Ico a u

full_name: nhdsWithin_Iic_basis'
code: theorem nhdsWithin_Iic_basis' [TopologicalSpace α] [LinearOrder α] [OrderTopology α] {a : α}
    (ha : ∃ l, l < a) : (𝓝[≤] a).HasBasis (fun l => l < a) fun l => Ioc l a 
goal: (𝓝[≤] a).HasBasis (fun l => l < a) fun l => Set.Ioc l a

full_name: nhdsWithin_Ici_basis
code: theorem nhdsWithin_Ici_basis [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [NoMaxOrder α]
    (a : α) : (𝓝[≥] a).HasBasis (fun u => a < u) fun u => Ico a u 
goal: (𝓝[≥] a).HasBasis (fun u => a < u) fun u => Set.Ico a u

full_name: nhdsWithin_Iic_basis
code: theorem nhdsWithin_Iic_basis [TopologicalSpace α] [LinearOrder α] [OrderTopology α] [NoMinOrder α]
    (a : α) : (𝓝[≤] a).HasBasis (fun l => l < a) fun l => Ioc l a 
goal: (𝓝[≤] a).HasBasis (fun l => l < a) fun l => Set.Ioc l a

full_name: nhds_top_order
code: theorem nhds_top_order [TopologicalSpace α] [Preorder α] [OrderTop α] [OrderTopology α] :
    𝓝 (⊤ : α) = ⨅ (l) (h₂ : l < ⊤), 𝓟 (Ioi l) 
goal: 𝓝 ⊤ = ⨅ l, ⨅ (_ : l < ⊤), 𝓟 (Set.Ioi l)

full_name: nhds_bot_order
code: theorem nhds_bot_order [TopologicalSpace α] [Preorder α] [OrderBot α] [OrderTopology α] :
    𝓝 (⊥ : α) = ⨅ (l) (h₂ : ⊥ < l), 𝓟 (Iio l) 
goal: 𝓝 ⊥ = ⨅ l, ⨅ (_ : ⊥ < l), 𝓟 (Set.Iio l)

full_name: nhds_top_basis
code: theorem nhds_top_basis [TopologicalSpace α] [LinearOrder α] [OrderTop α] [OrderTopology α]
    [Nontrivial α] : (𝓝 ⊤).HasBasis (fun a : α => a < ⊤) fun a : α => Ioi a 
goal: (𝓝 ⊤).HasBasis (fun a => a < ⊤) fun a => Set.Ioi a

full_name: nhds_bot_basis
code: theorem nhds_bot_basis [TopologicalSpace α] [LinearOrder α] [OrderBot α] [OrderTopology α]
    [Nontrivial α] : (𝓝 ⊥).HasBasis (fun a : α => ⊥ < a) fun a : α => Iio a 
goal: (𝓝 ⊥).HasBasis (fun a => ⊥ < a) fun a => Set.Iio a

full_name: nhds_top_basis_Ici
code: theorem nhds_top_basis_Ici [TopologicalSpace α] [LinearOrder α] [OrderTop α] [OrderTopology α]
    [Nontrivial α] [DenselyOrdered α] : (𝓝 ⊤).HasBasis (fun a : α => a < ⊤) Ici 
goal: (𝓝 ⊤).HasBasis (fun a => a < ⊤) Set.Ici

full_name: nhds_bot_basis_Iic
code: theorem nhds_bot_basis_Iic [TopologicalSpace α] [LinearOrder α] [OrderBot α] [OrderTopology α]
    [Nontrivial α] [DenselyOrdered α] : (𝓝 ⊥).HasBasis (fun a : α => ⊥ < a) Iic 
goal: (𝓝 ⊥).HasBasis (fun a => ⊥ < a) Set.Iic

full_name: tendsto_nhds_top_mono
code: theorem tendsto_nhds_top_mono [TopologicalSpace β] [Preorder β] [OrderTop β] [OrderTopology β]
    {l : Filter α} {f g : α → β} (hf : Tendsto f l (𝓝 ⊤)) (hg : f ≤ᶠ[l] g) : Tendsto g l (𝓝 ⊤) 
goal: Filter.Tendsto g l (𝓝 ⊤)

full_name: tendsto_nhds_bot_mono
code: theorem tendsto_nhds_bot_mono [TopologicalSpace β] [Preorder β] [OrderBot β] [OrderTopology β]
    {l : Filter α} {f g : α → β} (hf : Tendsto f l (𝓝 ⊥)) (hg : g ≤ᶠ[l] f) : Tendsto g l (𝓝 ⊥) 
goal: Filter.Tendsto g l (𝓝 ⊥)

full_name: tendsto_nhds_top_mono'
code: theorem tendsto_nhds_top_mono' [TopologicalSpace β] [Preorder β] [OrderTop β] [OrderTopology β]
    {l : Filter α} {f g : α → β} (hf : Tendsto f l (𝓝 ⊤)) (hg : f ≤ g) : Tendsto g l (𝓝 ⊤) 
goal: Filter.Tendsto g l (𝓝 ⊤)

full_name: tendsto_nhds_bot_mono'
code: theorem tendsto_nhds_bot_mono' [TopologicalSpace β] [Preorder β] [OrderBot β] [OrderTopology β]
    {l : Filter α} {f g : α → β} (hf : Tendsto f l (𝓝 ⊥)) (hg : g ≤ f) : Tendsto g l (𝓝 ⊥) 
goal: Filter.Tendsto g l (𝓝 ⊥)

full_name: order_separated
code: theorem order_separated [OrderTopology α] {a₁ a₂ : α} (h : a₁ < a₂) :
    ∃ u v : Set α, IsOpen u ∧ IsOpen v ∧ a₁ ∈ u ∧ a₂ ∈ v ∧ ∀ b₁ ∈ u, ∀ b₂ ∈ v, b₁ < b₂ 
goal: ∃ u v, IsOpen u ∧ IsOpen v ∧ a₁ ∈ u ∧ a₂ ∈ v ∧ ∀ b₁ ∈ u, ∀ b₂ ∈ v, b₁ < b₂

full_name: OrderTopology.to_orderClosedTopology
code: instance (priority := 100) OrderTopology.to_orderClosedTopology [OrderTopology α] :
    OrderClosedTopology α 
goal: OrderClosedTopology α

full_name: exists_Ioc_subset_of_mem_nhds
code: theorem exists_Ioc_subset_of_mem_nhds [OrderTopology α] {a : α} {s : Set α} (hs : s ∈ 𝓝 a)
    (h : ∃ l, l < a) : ∃ l < a, Ioc l a ⊆ s 
goal: ∃ l < a, Set.Ioc l a ⊆ s

full_name: exists_Ioc_subset_of_mem_nhds'
code: theorem exists_Ioc_subset_of_mem_nhds' [OrderTopology α] {a : α} {s : Set α} (hs : s ∈ 𝓝 a) {l : α}
    (hl : l < a) : ∃ l' ∈ Ico l a, Ioc l' a ⊆ s 
goal: ∃ l' ∈ Set.Ico l a, Set.Ioc l' a ⊆ s

full_name: exists_Ico_subset_of_mem_nhds'
code: theorem exists_Ico_subset_of_mem_nhds' [OrderTopology α] {a : α} {s : Set α} (hs : s ∈ 𝓝 a) {u : α}
    (hu : a < u) : ∃ u' ∈ Ioc a u, Ico a u' ⊆ s 
goal: ∃ u' ∈ Set.Ioc a u, Set.Ico a u' ⊆ s

full_name: exists_Ico_subset_of_mem_nhds
code: theorem exists_Ico_subset_of_mem_nhds [OrderTopology α] {a : α} {s : Set α} (hs : s ∈ 𝓝 a)
    (h : ∃ u, a < u) : ∃ u, a < u ∧ Ico a u ⊆ s 
goal: ∃ u, a < u ∧ Set.Ico a u ⊆ s

full_name: exists_Icc_mem_subset_of_mem_nhdsWithin_Ici
code: theorem exists_Icc_mem_subset_of_mem_nhdsWithin_Ici [OrderTopology α] {a : α} {s : Set α}
    (hs : s ∈ 𝓝[≥] a) : ∃ b, a ≤ b ∧ Icc a b ∈ 𝓝[≥] a ∧ Icc a b ⊆ s 
goal: ∃ b, a ≤ b ∧ Set.Icc a b ∈ 𝓝[≥] a ∧ Set.Icc a b ⊆ s

full_name: exists_Icc_mem_subset_of_mem_nhdsWithin_Iic
code: theorem exists_Icc_mem_subset_of_mem_nhdsWithin_Iic [OrderTopology α] {a : α} {s : Set α}
    (hs : s ∈ 𝓝[≤] a) : ∃ b ≤ a, Icc b a ∈ 𝓝[≤] a ∧ Icc b a ⊆ s 
goal: ∃ b ≤ a, Set.Icc b a ∈ 𝓝[≤] a ∧ Set.Icc b a ⊆ s

full_name: exists_Icc_mem_subset_of_mem_nhds
code: theorem exists_Icc_mem_subset_of_mem_nhds [OrderTopology α] {a : α} {s : Set α} (hs : s ∈ 𝓝 a) :
    ∃ b c, a ∈ Icc b c ∧ Icc b c ∈ 𝓝 a ∧ Icc b c ⊆ s 
goal: ∃ b c, a ∈ Set.Icc b c ∧ Set.Icc b c ∈ 𝓝 a ∧ Set.Icc b c ⊆ s

full_name: IsOpen.exists_Ioo_subset
code: theorem IsOpen.exists_Ioo_subset [OrderTopology α] [Nontrivial α] {s : Set α} (hs : IsOpen s)
    (h : s.Nonempty) : ∃ a b, a < b ∧ Ioo a b ⊆ s 
goal: ∃ a b, a < b ∧ Set.Ioo a b ⊆ s

full_name: dense_of_exists_between
code: theorem dense_of_exists_between [OrderTopology α] [Nontrivial α] {s : Set α}
    (h : ∀ ⦃a b⦄, a < b → ∃ c ∈ s, a < c ∧ c < b) : Dense s 
goal: Dense s

full_name: dense_iff_exists_between
code: /-- A set in a nontrivial densely linear ordered type is dense in the sense of topology if and only
if for any `a < b` there exists `c ∈ s`, `a < c < b`. Each implication requires less typeclass
assumptions. -/
theorem dense_iff_exists_between [OrderTopology α] [DenselyOrdered α] [Nontrivial α] {s : Set α} :
    Dense s ↔ ∀ a b, a < b → ∃ c ∈ s, a < c ∧ c < b 
goal: Dense s ↔ ∀ (a b : α), a < b → ∃ c ∈ s, a < c ∧ c < b

full_name: mem_nhds_iff_exists_Ioo_subset'
code: /-- A set is a neighborhood of `a` if and only if it contains an interval `(l, u)` containing `a`,
provided `a` is neither a bottom element nor a top element. -/
theorem mem_nhds_iff_exists_Ioo_subset' [OrderTopology α] {a : α} {s : Set α} (hl : ∃ l, l < a)
    (hu : ∃ u, a < u) : s ∈ 𝓝 a ↔ ∃ l u, a ∈ Ioo l u ∧ Ioo l u ⊆ s 
goal: s ∈ 𝓝 a ↔ ∃ l u, a ∈ Set.Ioo l u ∧ Set.Ioo l u ⊆ s

full_name: mem_nhds_iff_exists_Ioo_subset
code: /-- A set is a neighborhood of `a` if and only if it contains an interval `(l, u)` containing `a`.
-/
theorem mem_nhds_iff_exists_Ioo_subset [OrderTopology α] [NoMaxOrder α] [NoMinOrder α] {a : α}
    {s : Set α} : s ∈ 𝓝 a ↔ ∃ l u, a ∈ Ioo l u ∧ Ioo l u ⊆ s 
goal: s ∈ 𝓝 a ↔ ∃ l u, a ∈ Set.Ioo l u ∧ Set.Ioo l u ⊆ s

full_name: nhds_basis_Ioo'
code: theorem nhds_basis_Ioo' [OrderTopology α] {a : α} (hl : ∃ l, l < a) (hu : ∃ u, a < u) :
    (𝓝 a).HasBasis (fun b : α × α => b.1 < a ∧ a < b.2) fun b => Ioo b.1 b.2 
goal: (𝓝 a).HasBasis (fun b => b.1 < a ∧ a < b.2) fun b => Set.Ioo b.1 b.2

full_name: nhds_basis_Ioo
code: theorem nhds_basis_Ioo [OrderTopology α] [NoMaxOrder α] [NoMinOrder α] (a : α) :
    (𝓝 a).HasBasis (fun b : α × α => b.1 < a ∧ a < b.2) fun b => Ioo b.1 b.2 
goal: (𝓝 a).HasBasis (fun b => b.1 < a ∧ a < b.2) fun b => Set.Ioo b.1 b.2

full_name: Filter.Eventually.exists_Ioo_subset
code: theorem Filter.Eventually.exists_Ioo_subset [OrderTopology α] [NoMaxOrder α] [NoMinOrder α] {a : α}
    {p : α → Prop} (hp : ∀ᶠ x in 𝓝 a, p x) : ∃ l u, a ∈ Ioo l u ∧ Ioo l u ⊆ { x | p x } 
goal: ∃ l u, a ∈ Set.Ioo l u ∧ Set.Ioo l u ⊆ {x | p x}

full_name: Dense.topology_eq_generateFrom
code: theorem Dense.topology_eq_generateFrom [OrderTopology α] [DenselyOrdered α] {s : Set α}
    (hs : Dense s) : ‹TopologicalSpace α› = .generateFrom (Ioi '' s ∪ Iio '' s) 
goal: inst✝ = TopologicalSpace.generateFrom (Set.Ioi '' s ∪ Set.Iio '' s)

full_name: atBot_le_nhds_bot
code: @[deprecated OrderBot.atBot_eq (since := "2024-02-14")]
theorem atBot_le_nhds_bot [OrderBot α] : (atBot : Filter α) ≤ 𝓝 ⊥ 
goal: Filter.atBot ≤ 𝓝 ⊥

full_name: atTop_le_nhds_top
code: @[deprecated OrderTop.atTop_eq (since := "2024-02-14")]
theorem atTop_le_nhds_top [OrderTop α] : (atTop : Filter α) ≤ 𝓝 ⊤ 
goal: Filter.atTop ≤ 𝓝 ⊤

full_name: SecondCountableTopology.of_separableSpace_orderTopology
code: /-- Let `α` be a densely ordered linear order with order topology. If `α` is a separable space, then
it has second countable topology. Note that the "densely ordered" assumption cannot be dropped, see
[double arrow space](https://topology.pi-base.org/spaces/S000093) for a counterexample. -/
theorem SecondCountableTopology.of_separableSpace_orderTopology [OrderTopology α] [DenselyOrdered α]
    [SeparableSpace α] : SecondCountableTopology α 
goal: SecondCountableTopology α

full_name: countable_setOf_covBy_right
code: /-- The set of points which are isolated on the right is countable when the space is
second-countable. -/
theorem countable_setOf_covBy_right [OrderTopology α] [SecondCountableTopology α] :
    Set.Countable { x : α | ∃ y, x ⋖ y } 
goal: {x | ∃ y, x ⋖ y}.Countable

full_name: countable_setOf_covBy_left
code: /-- The set of points which are isolated on the left is countable when the space is
second-countable. -/
theorem countable_setOf_covBy_left [OrderTopology α] [SecondCountableTopology α] :
    Set.Countable { x : α | ∃ y, y ⋖ x } 
goal: {x | ∃ y, y ⋖ x}.Countable

full_name: countable_of_isolated_left'
code: /-- The set of points which are isolated on the left is countable when the space is
second-countable. -/
theorem countable_of_isolated_left' [OrderTopology α] [SecondCountableTopology α] :
    Set.Countable { x : α | ∃ y, y < x ∧ Ioo y x = ∅ } 
goal: {x | ∃ y < x, Set.Ioo y x = ∅}.Countable

full_name: Set.PairwiseDisjoint.countable_of_Ioo
code: /-- Consider a disjoint family of intervals `(x, y)` with `x < y` in a second-countable space.
Then the family is countable.
This is not a straightforward consequence of second-countability as some of these intervals might be
empty (but in fact this can happen only for countably many of them). -/
theorem Set.PairwiseDisjoint.countable_of_Ioo [OrderTopology α] [SecondCountableTopology α]
    {y : α → α} {s : Set α} (h : PairwiseDisjoint s fun x => Ioo x (y x))
    (h' : ∀ x ∈ s, x < y x) : s.Countable 
goal: s.Countable

full_name: countable_image_lt_image_Ioi
code: /-- For a function taking values in a second countable space, the set of points `x` for
which the image under `f` of `(x, ∞)` is separated above from `f x` is countable. -/
theorem countable_image_lt_image_Ioi [OrderTopology α] [LinearOrder β] (f : β → α)
    [SecondCountableTopology α] : Set.Countable {x | ∃ z, f x < z ∧ ∀ y, x < y → z ≤ f y} 
goal: {x | ∃ z, f x < z ∧ ∀ (y : β), x < y → z ≤ f y}.Countable

full_name: countable_image_gt_image_Ioi
code: /-- For a function taking values in a second countable space, the set of points `x` for
which the image under `f` of `(x, ∞)` is separated below from `f x` is countable. -/
theorem countable_image_gt_image_Ioi [OrderTopology α] [LinearOrder β] (f : β → α)
    [SecondCountableTopology α] : Set.Countable {x | ∃ z, z < f x ∧ ∀ y, x < y → f y ≤ z} 
goal: {x | ∃ z < f x, ∀ (y : β), x < y → f y ≤ z}.Countable

full_name: countable_image_lt_image_Iio
code: /-- For a function taking values in a second countable space, the set of points `x` for
which the image under `f` of `(-∞, x)` is separated above from `f x` is countable. -/
theorem countable_image_lt_image_Iio [OrderTopology α] [LinearOrder β] (f : β → α)
    [SecondCountableTopology α] : Set.Countable {x | ∃ z, f x < z ∧ ∀ y, y < x → z ≤ f y} 
goal: {x | ∃ z, f x < z ∧ ∀ y < x, z ≤ f y}.Countable

full_name: countable_image_gt_image_Iio
code: /-- For a function taking values in a second countable space, the set of points `x` for
which the image under `f` of `(-∞, x)` is separated below from `f x` is countable. -/
theorem countable_image_gt_image_Iio [OrderTopology α] [LinearOrder β] (f : β → α)
    [SecondCountableTopology α] : Set.Countable {x | ∃ z, z < f x ∧ ∀ y, y < x → f y ≤ z} 
goal: {x | ∃ z < f x, ∀ y < x, f y ≤ z}.Countable

full_name: instIsCountablyGenerated_atTop
code: instance instIsCountablyGenerated_atTop [OrderTopology α] [SecondCountableTopology α] :
    IsCountablyGenerated (atTop : Filter α) 
goal: Filter.atTop.IsCountablyGenerated

full_name: instIsCountablyGenerated_atBot
code: instance instIsCountablyGenerated_atBot [OrderTopology α] [SecondCountableTopology α] :
    IsCountablyGenerated (atBot : Filter α) 
goal: Filter.atBot.IsCountablyGenerated

full_name: pi_Iic_mem_nhds
code: theorem pi_Iic_mem_nhds (ha : ∀ i, x i < a i) : Iic a ∈ 𝓝 x 
goal: Set.Iic a ∈ 𝓝 x

full_name: pi_Iic_mem_nhds'
code: theorem pi_Iic_mem_nhds' (ha : ∀ i, x' i < a' i) : Iic a' ∈ 𝓝 x' 
goal: Set.Iic a' ∈ 𝓝 x'

full_name: pi_Ici_mem_nhds
code: theorem pi_Ici_mem_nhds (ha : ∀ i, a i < x i) : Ici a ∈ 𝓝 x 
goal: Set.Ici a ∈ 𝓝 x

full_name: pi_Ici_mem_nhds'
code: theorem pi_Ici_mem_nhds' (ha : ∀ i, a' i < x' i) : Ici a' ∈ 𝓝 x' 
goal: Set.Ici a' ∈ 𝓝 x'

full_name: pi_Icc_mem_nhds
code: theorem pi_Icc_mem_nhds (ha : ∀ i, a i < x i) (hb : ∀ i, x i < b i) : Icc a b ∈ 𝓝 x 
goal: Set.Icc a b ∈ 𝓝 x

full_name: pi_Icc_mem_nhds'
code: theorem pi_Icc_mem_nhds' (ha : ∀ i, a' i < x' i) (hb : ∀ i, x' i < b' i) : Icc a' b' ∈ 𝓝 x' 
goal: Set.Icc a' b' ∈ 𝓝 x'

full_name: pi_Iio_mem_nhds
code: theorem pi_Iio_mem_nhds (ha : ∀ i, x i < a i) : Iio a ∈ 𝓝 x 
goal: Set.Iio a ∈ 𝓝 x

full_name: pi_Iio_mem_nhds'
code: theorem pi_Iio_mem_nhds' (ha : ∀ i, x' i < a' i) : Iio a' ∈ 𝓝 x' 
goal: Set.Iio a' ∈ 𝓝 x'

full_name: pi_Ioi_mem_nhds
code: theorem pi_Ioi_mem_nhds (ha : ∀ i, a i < x i) : Ioi a ∈ 𝓝 x 
goal: Set.Ioi a ∈ 𝓝 x

full_name: pi_Ioi_mem_nhds'
code: theorem pi_Ioi_mem_nhds' (ha : ∀ i, a' i < x' i) : Ioi a' ∈ 𝓝 x' 
goal: Set.Ioi a' ∈ 𝓝 x'

full_name: pi_Ioc_mem_nhds
code: theorem pi_Ioc_mem_nhds (ha : ∀ i, a i < x i) (hb : ∀ i, x i < b i) : Ioc a b ∈ 𝓝 x 
goal: Set.Ioc a b ∈ 𝓝 x

full_name: pi_Ioc_mem_nhds'
code: theorem pi_Ioc_mem_nhds' (ha : ∀ i, a' i < x' i) (hb : ∀ i, x' i < b' i) : Ioc a' b' ∈ 𝓝 x' 
goal: Set.Ioc a' b' ∈ 𝓝 x'

full_name: pi_Ico_mem_nhds
code: theorem pi_Ico_mem_nhds (ha : ∀ i, a i < x i) (hb : ∀ i, x i < b i) : Ico a b ∈ 𝓝 x 
goal: Set.Ico a b ∈ 𝓝 x

full_name: pi_Ico_mem_nhds'
code: theorem pi_Ico_mem_nhds' (ha : ∀ i, a' i < x' i) (hb : ∀ i, x' i < b' i) : Ico a' b' ∈ 𝓝 x' 
goal: Set.Ico a' b' ∈ 𝓝 x'

full_name: pi_Ioo_mem_nhds
code: theorem pi_Ioo_mem_nhds (ha : ∀ i, a i < x i) (hb : ∀ i, x i < b i) : Ioo a b ∈ 𝓝 x 
goal: Set.Ioo a b ∈ 𝓝 x

full_name: pi_Ioo_mem_nhds'
code: theorem pi_Ioo_mem_nhds' (ha : ∀ i, a' i < x' i) (hb : ∀ i, x' i < b' i) : Ioo a' b' ∈ 𝓝 x' 
goal: Set.Ioo a' b' ∈ 𝓝 x'