File: Mathlib/Topology/Order/DenselyOrdered.lean

full_name: closure_Ioi'
code: /-- The closure of the interval `(a, +∞)` is the closed interval `[a, +∞)`, unless `a` is a top
element. -/
theorem closure_Ioi' {a : α} (h : (Ioi a).Nonempty) : closure (Ioi a) = Ici a 
goal: closure (Set.Ioi a) = Set.Ici a

full_name: closure_Ioi
code: /-- The closure of the interval `(a, +∞)` is the closed interval `[a, +∞)`. -/
@[simp]
theorem closure_Ioi (a : α) [NoMaxOrder α] : closure (Ioi a) = Ici a 
goal: closure (Set.Ioi a) = Set.Ici a

full_name: closure_Iio'
code: /-- The closure of the interval `(-∞, a)` is the closed interval `(-∞, a]`, unless `a` is a bottom
element. -/
theorem closure_Iio' (h : (Iio a).Nonempty) : closure (Iio a) = Iic a 
goal: closure (Set.Iio a) = Set.Iic a

full_name: closure_Iio
code: /-- The closure of the interval `(-∞, a)` is the interval `(-∞, a]`. -/
@[simp]
theorem closure_Iio (a : α) [NoMinOrder α] : closure (Iio a) = Iic a 
goal: closure (Set.Iio a) = Set.Iic a

full_name: closure_Ioo
code: /-- The closure of the open interval `(a, b)` is the closed interval `[a, b]`. -/
@[simp]
theorem closure_Ioo {a b : α} (hab : a ≠ b) : closure (Ioo a b) = Icc a b 
goal: closure (Set.Ioo a b) = Set.Icc a b

full_name: closure_Ioc
code: /-- The closure of the interval `(a, b]` is the closed interval `[a, b]`. -/
@[simp]
theorem closure_Ioc {a b : α} (hab : a ≠ b) : closure (Ioc a b) = Icc a b 
goal: closure (Set.Ioc a b) = Set.Icc a b

full_name: closure_Ico
code: /-- The closure of the interval `[a, b)` is the closed interval `[a, b]`. -/
@[simp]
theorem closure_Ico {a b : α} (hab : a ≠ b) : closure (Ico a b) = Icc a b 
goal: closure (Set.Ico a b) = Set.Icc a b

full_name: interior_Ici'
code: @[simp]
theorem interior_Ici' {a : α} (ha : (Iio a).Nonempty) : interior (Ici a) = Ioi a 
goal: interior (Set.Ici a) = Set.Ioi a

full_name: interior_Ici
code: theorem interior_Ici [NoMinOrder α] {a : α} : interior (Ici a) = Ioi a 
goal: interior (Set.Ici a) = Set.Ioi a

full_name: interior_Iic'
code: @[simp]
theorem interior_Iic' {a : α} (ha : (Ioi a).Nonempty) : interior (Iic a) = Iio a 
goal: interior (Set.Iic a) = Set.Iio a

full_name: interior_Iic
code: theorem interior_Iic [NoMaxOrder α] {a : α} : interior (Iic a) = Iio a 
goal: interior (Set.Iic a) = Set.Iio a

full_name: interior_Icc
code: @[simp]
theorem interior_Icc [NoMinOrder α] [NoMaxOrder α] {a b : α} : interior (Icc a b) = Ioo a b 
goal: interior (Set.Icc a b) = Set.Ioo a b

full_name: Icc_mem_nhds_iff
code: @[simp]
theorem Icc_mem_nhds_iff [NoMinOrder α] [NoMaxOrder α] {a b x : α} :
    Icc a b ∈ 𝓝 x ↔ x ∈ Ioo a b 
goal: Set.Icc a b ∈ 𝓝 x ↔ x ∈ Set.Ioo a b

full_name: interior_Ico
code: @[simp]
theorem interior_Ico [NoMinOrder α] {a b : α} : interior (Ico a b) = Ioo a b 
goal: interior (Set.Ico a b) = Set.Ioo a b

full_name: Ico_mem_nhds_iff
code: @[simp]
theorem Ico_mem_nhds_iff [NoMinOrder α] {a b x : α} : Ico a b ∈ 𝓝 x ↔ x ∈ Ioo a b 
goal: Set.Ico a b ∈ 𝓝 x ↔ x ∈ Set.Ioo a b

full_name: interior_Ioc
code: @[simp]
theorem interior_Ioc [NoMaxOrder α] {a b : α} : interior (Ioc a b) = Ioo a b 
goal: interior (Set.Ioc a b) = Set.Ioo a b

full_name: Ioc_mem_nhds_iff
code: @[simp]
theorem Ioc_mem_nhds_iff [NoMaxOrder α] {a b x : α} : Ioc a b ∈ 𝓝 x ↔ x ∈ Ioo a b 
goal: Set.Ioc a b ∈ 𝓝 x ↔ x ∈ Set.Ioo a b

full_name: closure_interior_Icc
code: theorem closure_interior_Icc {a b : α} (h : a ≠ b) : closure (interior (Icc a b)) = Icc a b 
goal: closure (interior (Set.Icc a b)) = Set.Icc a b

full_name: Ioc_subset_closure_interior
code: theorem Ioc_subset_closure_interior (a b : α) : Ioc a b ⊆ closure (interior (Ioc a b)) 
goal: Set.Ioc a b ⊆ closure (interior (Set.Ioc a b))

full_name: Ico_subset_closure_interior
code: theorem Ico_subset_closure_interior (a b : α) : Ico a b ⊆ closure (interior (Ico a b)) 
goal: Set.Ico a b ⊆ closure (interior (Set.Ico a b))

full_name: frontier_Ici'
code: @[simp]
theorem frontier_Ici' {a : α} (ha : (Iio a).Nonempty) : frontier (Ici a) = {a} 
goal: frontier (Set.Ici a) = {a}

full_name: frontier_Ici
code: theorem frontier_Ici [NoMinOrder α] {a : α} : frontier (Ici a) = {a} 
goal: frontier (Set.Ici a) = {a}

full_name: frontier_Iic'
code: @[simp]
theorem frontier_Iic' {a : α} (ha : (Ioi a).Nonempty) : frontier (Iic a) = {a} 
goal: frontier (Set.Iic a) = {a}

full_name: frontier_Iic
code: theorem frontier_Iic [NoMaxOrder α] {a : α} : frontier (Iic a) = {a} 
goal: frontier (Set.Iic a) = {a}

full_name: frontier_Ioi'
code: @[simp]
theorem frontier_Ioi' {a : α} (ha : (Ioi a).Nonempty) : frontier (Ioi a) = {a} 
goal: frontier (Set.Ioi a) = {a}

full_name: frontier_Ioi
code: theorem frontier_Ioi [NoMaxOrder α] {a : α} : frontier (Ioi a) = {a} 
goal: frontier (Set.Ioi a) = {a}

full_name: frontier_Iio'
code: @[simp]
theorem frontier_Iio' {a : α} (ha : (Iio a).Nonempty) : frontier (Iio a) = {a} 
goal: frontier (Set.Iio a) = {a}

full_name: frontier_Iio
code: theorem frontier_Iio [NoMinOrder α] {a : α} : frontier (Iio a) = {a} 
goal: frontier (Set.Iio a) = {a}

full_name: frontier_Icc
code: @[simp]
theorem frontier_Icc [NoMinOrder α] [NoMaxOrder α] {a b : α} (h : a ≤ b) :
    frontier (Icc a b) = {a, b} 
goal: frontier (Set.Icc a b) = {a, b}

full_name: frontier_Ioo
code: @[simp]
theorem frontier_Ioo {a b : α} (h : a < b) : frontier (Ioo a b) = {a, b} 
goal: frontier (Set.Ioo a b) = {a, b}

full_name: frontier_Ico
code: @[simp]
theorem frontier_Ico [NoMinOrder α] {a b : α} (h : a < b) : frontier (Ico a b) = {a, b} 
goal: frontier (Set.Ico a b) = {a, b}

full_name: frontier_Ioc
code: @[simp]
theorem frontier_Ioc [NoMaxOrder α] {a b : α} (h : a < b) : frontier (Ioc a b) = {a, b} 
goal: frontier (Set.Ioc a b) = {a, b}

full_name: nhdsWithin_Ioi_neBot'
code: theorem nhdsWithin_Ioi_neBot' {a b : α} (H₁ : (Ioi a).Nonempty) (H₂ : a ≤ b) :
    NeBot (𝓝[Ioi a] b) 
goal: (𝓝[Set.Ioi a] b).NeBot

full_name: nhdsWithin_Ioi_neBot
code: theorem nhdsWithin_Ioi_neBot [NoMaxOrder α] {a b : α} (H : a ≤ b) : NeBot (𝓝[Ioi a] b) 
goal: (𝓝[Set.Ioi a] b).NeBot

full_name: nhdsWithin_Ioi_self_neBot'
code: theorem nhdsWithin_Ioi_self_neBot' {a : α} (H : (Ioi a).Nonempty) : NeBot (𝓝[>] a) 
goal: (𝓝[>] a).NeBot

full_name: nhdsWithin_Ioi_self_neBot
code: instance nhdsWithin_Ioi_self_neBot [NoMaxOrder α] (a : α) : NeBot (𝓝[>] a) 
goal: (𝓝[>] a).NeBot

full_name: nhdsWithin_Iio_neBot'
code: theorem nhdsWithin_Iio_neBot' {b c : α} (H₁ : (Iio c).Nonempty) (H₂ : b ≤ c) :
    NeBot (𝓝[Iio c] b) 
goal: (𝓝[Set.Iio c] b).NeBot

full_name: nhdsWithin_Iio_neBot
code: theorem nhdsWithin_Iio_neBot [NoMinOrder α] {a b : α} (H : a ≤ b) : NeBot (𝓝[Iio b] a) 
goal: (𝓝[Set.Iio b] a).NeBot

full_name: nhdsWithin_Iio_self_neBot'
code: theorem nhdsWithin_Iio_self_neBot' {b : α} (H : (Iio b).Nonempty) : NeBot (𝓝[<] b) 
goal: (𝓝[<] b).NeBot

full_name: nhdsWithin_Iio_self_neBot
code: instance nhdsWithin_Iio_self_neBot [NoMinOrder α] (a : α) : NeBot (𝓝[<] a) 
goal: (𝓝[<] a).NeBot

full_name: right_nhdsWithin_Ico_neBot
code: theorem right_nhdsWithin_Ico_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ico a b] b) 
goal: (𝓝[Set.Ico a b] b).NeBot

full_name: left_nhdsWithin_Ioc_neBot
code: theorem left_nhdsWithin_Ioc_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ioc a b] a) 
goal: (𝓝[Set.Ioc a b] a).NeBot

full_name: left_nhdsWithin_Ioo_neBot
code: theorem left_nhdsWithin_Ioo_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ioo a b] a) 
goal: (𝓝[Set.Ioo a b] a).NeBot

full_name: right_nhdsWithin_Ioo_neBot
code: theorem right_nhdsWithin_Ioo_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ioo a b] b) 
goal: (𝓝[Set.Ioo a b] b).NeBot

full_name: comap_coe_nhdsWithin_Iio_of_Ioo_subset
code: theorem comap_coe_nhdsWithin_Iio_of_Ioo_subset (hb : s ⊆ Iio b)
    (hs : s.Nonempty → ∃ a < b, Ioo a b ⊆ s) : comap ((↑) : s → α) (𝓝[<] b) = atTop 
goal: Filter.comap Subtype.val (𝓝[<] b) = Filter.atTop

full_name: comap_coe_nhdsWithin_Ioi_of_Ioo_subset
code: theorem comap_coe_nhdsWithin_Ioi_of_Ioo_subset (ha : s ⊆ Ioi a)
    (hs : s.Nonempty → ∃ b > a, Ioo a b ⊆ s) : comap ((↑) : s → α) (𝓝[>] a) = atBot 
goal: Filter.comap Subtype.val (𝓝[>] a) = Filter.atBot

full_name: map_coe_atTop_of_Ioo_subset
code: theorem map_coe_atTop_of_Ioo_subset (hb : s ⊆ Iio b) (hs : ∀ a' < b, ∃ a < b, Ioo a b ⊆ s) :
    map ((↑) : s → α) atTop = 𝓝[<] b 
goal: Filter.map Subtype.val Filter.atTop = 𝓝[<] b

full_name: map_coe_atBot_of_Ioo_subset
code: theorem map_coe_atBot_of_Ioo_subset (ha : s ⊆ Ioi a) (hs : ∀ b' > a, ∃ b > a, Ioo a b ⊆ s) :
    map ((↑) : s → α) atBot = 𝓝[>] a 
goal: Filter.map Subtype.val Filter.atBot = 𝓝[>] a

full_name: comap_coe_Ioo_nhdsWithin_Iio
code: /-- The `atTop` filter for an open interval `Ioo a b` comes from the left-neighbourhoods filter at
the right endpoint in the ambient order. -/
theorem comap_coe_Ioo_nhdsWithin_Iio (a b : α) : comap ((↑) : Ioo a b → α) (𝓝[<] b) = atTop 
goal: Filter.comap Subtype.val (𝓝[<] b) = Filter.atTop

full_name: comap_coe_Ioo_nhdsWithin_Ioi
code: /-- The `atBot` filter for an open interval `Ioo a b` comes from the right-neighbourhoods filter at
the left endpoint in the ambient order. -/
theorem comap_coe_Ioo_nhdsWithin_Ioi (a b : α) : comap ((↑) : Ioo a b → α) (𝓝[>] a) = atBot 
goal: Filter.comap Subtype.val (𝓝[>] a) = Filter.atBot

full_name: comap_coe_Ioi_nhdsWithin_Ioi
code: theorem comap_coe_Ioi_nhdsWithin_Ioi (a : α) : comap ((↑) : Ioi a → α) (𝓝[>] a) = atBot 
goal: Filter.comap Subtype.val (𝓝[>] a) = Filter.atBot

full_name: comap_coe_Iio_nhdsWithin_Iio
code: theorem comap_coe_Iio_nhdsWithin_Iio (a : α) : comap ((↑) : Iio a → α) (𝓝[<] a) = atTop 
goal: Filter.comap Subtype.val (𝓝[<] a) = Filter.atTop

full_name: map_coe_Ioo_atTop
code: @[simp]
theorem map_coe_Ioo_atTop {a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atTop = 𝓝[<] b 
goal: Filter.map Subtype.val Filter.atTop = 𝓝[<] b

full_name: map_coe_Ioo_atBot
code: @[simp]
theorem map_coe_Ioo_atBot {a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atBot = 𝓝[>] a 
goal: Filter.map Subtype.val Filter.atBot = 𝓝[>] a

full_name: map_coe_Ioi_atBot
code: @[simp]
theorem map_coe_Ioi_atBot (a : α) : map ((↑) : Ioi a → α) atBot = 𝓝[>] a 
goal: Filter.map Subtype.val Filter.atBot = 𝓝[>] a

full_name: map_coe_Iio_atTop
code: @[simp]
theorem map_coe_Iio_atTop (a : α) : map ((↑) : Iio a → α) atTop = 𝓝[<] a 
goal: Filter.map Subtype.val Filter.atTop = 𝓝[<] a

full_name: tendsto_comp_coe_Ioo_atTop
code: @[simp]
theorem tendsto_comp_coe_Ioo_atTop (h : a < b) :
    Tendsto (fun x : Ioo a b => f x) atTop l ↔ Tendsto f (𝓝[<] b) l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atTop l ↔ Filter.Tendsto f (𝓝[<] b) l

full_name: tendsto_comp_coe_Ioo_atBot
code: @[simp]
theorem tendsto_comp_coe_Ioo_atBot (h : a < b) :
    Tendsto (fun x : Ioo a b => f x) atBot l ↔ Tendsto f (𝓝[>] a) l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atBot l ↔ Filter.Tendsto f (𝓝[>] a) l

full_name: tendsto_comp_coe_Ioi_atBot
code: @[simp, nolint simpNF]
theorem tendsto_comp_coe_Ioi_atBot :
    Tendsto (fun x : Ioi a => f x) atBot l ↔ Tendsto f (𝓝[>] a) l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atBot l ↔ Filter.Tendsto f (𝓝[>] a) l

full_name: tendsto_comp_coe_Iio_atTop
code: @[simp, nolint simpNF]
theorem tendsto_comp_coe_Iio_atTop :
    Tendsto (fun x : Iio a => f x) atTop l ↔ Tendsto f (𝓝[<] a) l 
goal: Filter.Tendsto (fun x => f ↑x) Filter.atTop l ↔ Filter.Tendsto f (𝓝[<] a) l

full_name: tendsto_Ioo_atTop
code: @[simp]
theorem tendsto_Ioo_atTop {f : β → Ioo a b} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l (𝓝[<] b) 
goal: Filter.Tendsto f l Filter.atTop ↔ Filter.Tendsto (fun x => ↑(f x)) l (𝓝[<] b)

full_name: tendsto_Ioo_atBot
code: @[simp]
theorem tendsto_Ioo_atBot {f : β → Ioo a b} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l (𝓝[>] a) 
goal: Filter.Tendsto f l Filter.atBot ↔ Filter.Tendsto (fun x => ↑(f x)) l (𝓝[>] a)

full_name: tendsto_Ioi_atBot
code: @[simp]
theorem tendsto_Ioi_atBot {f : β → Ioi a} :
    Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l (𝓝[>] a) 
goal: Filter.Tendsto f l Filter.atBot ↔ Filter.Tendsto (fun x => ↑(f x)) l (𝓝[>] a)

full_name: tendsto_Iio_atTop
code: @[simp]
theorem tendsto_Iio_atTop {f : β → Iio a} :
    Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l (𝓝[<] a) 
goal: Filter.Tendsto f l Filter.atTop ↔ Filter.Tendsto (fun x => ↑(f x)) l (𝓝[<] a)

full_name: instNeBotNhdsWithinComplSetSingletonOfNontrivial
code: instance (x : α) [Nontrivial α] : NeBot (𝓝[≠] x) 
goal: (𝓝[≠] x).NeBot

full_name: Dense.exists_countable_dense_subset_no_bot_top
code: /-- Let `s` be a dense set in a nontrivial dense linear order `α`. If `s` is a
separable space (e.g., if `α` has a second countable topology), then there exists a countable
dense subset `t ⊆ s` such that `t` does not contain bottom/top elements of `α`. -/
theorem Dense.exists_countable_dense_subset_no_bot_top [Nontrivial α] {s : Set α} [SeparableSpace s]
    (hs : Dense s) :
    ∃ t, t ⊆ s ∧ t.Countable ∧ Dense t ∧ (∀ x, IsBot x → x ∉ t) ∧ ∀ x, IsTop x → x ∉ t 
goal: ∃ t ⊆ s, t.Countable ∧ Dense t ∧ (∀ (x : α), IsBot x → x ∉ t) ∧ ∀ (x : α), IsTop x → x ∉ t

full_name: exists_countable_dense_no_bot_top
code: /-- If `α` is a nontrivial separable dense linear order, then there exists a
countable dense set `s : Set α` that contains neither top nor bottom elements of `α`.
For a dense set containing both bot and top elements, see
`exists_countable_dense_bot_top`. -/
theorem exists_countable_dense_no_bot_top [SeparableSpace α] [Nontrivial α] :
    ∃ s : Set α, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∉ s) ∧ ∀ x, IsTop x → x ∉ s 
goal: ∃ s, s.Countable ∧ Dense s ∧ (∀ (x : α), IsBot x → x ∉ s) ∧ ∀ (x : α), IsTop x → x ∉ s