Module docstring
{"# Order topology on a densely ordered set "}
{"# Order topology on a densely ordered set "}
closure_Ioi'
theorem
{a : α} (h : (Ioi a).Nonempty) : closure (Ioi a) = Ici a
/-- 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 := by
apply Subset.antisymm
· exact closure_minimal Ioi_subset_Ici_self isClosed_Ici
· rw [← diff_subset_closure_iff, Ici_diff_Ioi_same, singleton_subset_iff]
exact isGLB_Ioi.mem_closure h
closure_Ioi
theorem
(a : α) [NoMaxOrder α] : closure (Ioi a) = Ici a
/-- The closure of the interval `(a, +∞)` is the closed interval `[a, +∞)`. -/
@[simp]
theorem closure_Ioi (a : α) [NoMaxOrder α] : closure (Ioi a) = Ici a :=
closure_Ioi' nonempty_Ioi
closure_Iio'
theorem
(h : (Iio a).Nonempty) : closure (Iio a) = Iic a
/-- 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 :=
closure_Ioi' (α := αᵒᵈ) h
closure_Iio
theorem
(a : α) [NoMinOrder α] : closure (Iio a) = Iic a
/-- The closure of the interval `(-∞, a)` is the interval `(-∞, a]`. -/
@[simp]
theorem closure_Iio (a : α) [NoMinOrder α] : closure (Iio a) = Iic a :=
closure_Iio' nonempty_Iio
closure_Ioo
theorem
{a b : α} (hab : a ≠ b) : closure (Ioo a b) = Icc a b
/-- 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 := by
apply Subset.antisymm
· exact closure_minimal Ioo_subset_Icc_self isClosed_Icc
· rcases hab.lt_or_lt with hab | hab
· rw [← diff_subset_closure_iff, Icc_diff_Ioo_same hab.le]
have hab' : (Ioo a b).Nonempty := nonempty_Ioo.2 hab
simp only [insert_subset_iff, singleton_subset_iff]
exact ⟨(isGLB_Ioo hab).mem_closure hab', (isLUB_Ioo hab).mem_closure hab'⟩
· rw [Icc_eq_empty_of_lt hab]
exact empty_subset _
closure_Ioc
theorem
{a b : α} (hab : a ≠ b) : closure (Ioc a b) = Icc a b
/-- 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 := by
apply Subset.antisymm
· exact closure_minimal Ioc_subset_Icc_self isClosed_Icc
· apply Subset.trans _ (closure_mono Ioo_subset_Ioc_self)
rw [closure_Ioo hab]
closure_Ico
theorem
{a b : α} (hab : a ≠ b) : closure (Ico a b) = Icc a b
/-- 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 := by
apply Subset.antisymm
· exact closure_minimal Ico_subset_Icc_self isClosed_Icc
· apply Subset.trans _ (closure_mono Ioo_subset_Ico_self)
rw [closure_Ioo hab]
interior_Ici'
theorem
{a : α} (ha : (Iio a).Nonempty) : interior (Ici a) = Ioi a
@[simp]
theorem interior_Ici' {a : α} (ha : (Iio a).Nonempty) : interior (Ici a) = Ioi a := by
rw [← compl_Iio, interior_compl, closure_Iio' ha, compl_Iic]
interior_Ici
theorem
[NoMinOrder α] {a : α} : interior (Ici a) = Ioi a
theorem interior_Ici [NoMinOrder α] {a : α} : interior (Ici a) = Ioi a :=
interior_Ici' nonempty_Iio
interior_Iic'
theorem
{a : α} (ha : (Ioi a).Nonempty) : interior (Iic a) = Iio a
@[simp]
theorem interior_Iic' {a : α} (ha : (Ioi a).Nonempty) : interior (Iic a) = Iio a :=
interior_Ici' (α := αᵒᵈ) ha
interior_Iic
theorem
[NoMaxOrder α] {a : α} : interior (Iic a) = Iio a
theorem interior_Iic [NoMaxOrder α] {a : α} : interior (Iic a) = Iio a :=
interior_Iic' nonempty_Ioi
interior_Icc
theorem
[NoMinOrder α] [NoMaxOrder α] {a b : α} : interior (Icc a b) = Ioo a b
@[simp]
theorem interior_Icc [NoMinOrder α] [NoMaxOrder α] {a b : α} : interior (Icc a b) = Ioo a b := by
rw [← Ici_inter_Iic, interior_inter, interior_Ici, interior_Iic, Ioi_inter_Iio]
Icc_mem_nhds_iff
theorem
[NoMinOrder α] [NoMaxOrder α] {a b x : α} : Icc a b ∈ 𝓝 x ↔ x ∈ Ioo a b
@[simp]
theorem Icc_mem_nhds_iff [NoMinOrder α] [NoMaxOrder α] {a b x : α} :
IccIcc a b ∈ 𝓝 xIcc a b ∈ 𝓝 x ↔ x ∈ Ioo a b := by
rw [← interior_Icc, mem_interior_iff_mem_nhds]
interior_Ico
theorem
[NoMinOrder α] {a b : α} : interior (Ico a b) = Ioo a b
@[simp]
theorem interior_Ico [NoMinOrder α] {a b : α} : interior (Ico a b) = Ioo a b := by
rw [← Ici_inter_Iio, interior_inter, interior_Ici, interior_Iio, Ioi_inter_Iio]
Ico_mem_nhds_iff
theorem
[NoMinOrder α] {a b x : α} : Ico a b ∈ 𝓝 x ↔ x ∈ Ioo a b
@[simp]
theorem Ico_mem_nhds_iff [NoMinOrder α] {a b x : α} : IcoIco a b ∈ 𝓝 xIco a b ∈ 𝓝 x ↔ x ∈ Ioo a b := by
rw [← interior_Ico, mem_interior_iff_mem_nhds]
interior_Ioc
theorem
[NoMaxOrder α] {a b : α} : interior (Ioc a b) = Ioo a b
@[simp]
theorem interior_Ioc [NoMaxOrder α] {a b : α} : interior (Ioc a b) = Ioo a b := by
rw [← Ioi_inter_Iic, interior_inter, interior_Ioi, interior_Iic, Ioi_inter_Iio]
Ioc_mem_nhds_iff
theorem
[NoMaxOrder α] {a b x : α} : Ioc a b ∈ 𝓝 x ↔ x ∈ Ioo a b
@[simp]
theorem Ioc_mem_nhds_iff [NoMaxOrder α] {a b x : α} : IocIoc a b ∈ 𝓝 xIoc a b ∈ 𝓝 x ↔ x ∈ Ioo a b := by
rw [← interior_Ioc, mem_interior_iff_mem_nhds]
closure_interior_Icc
theorem
{a b : α} (h : a ≠ b) : closure (interior (Icc a b)) = Icc a b
theorem closure_interior_Icc {a b : α} (h : a ≠ b) : closure (interior (Icc a b)) = Icc a b :=
(closure_minimal interior_subset isClosed_Icc).antisymm <|
calc
Icc a b = closure (Ioo a b) := (closure_Ioo h).symm
_ ⊆ closure (interior (Icc a b)) :=
closure_mono (interior_maximal Ioo_subset_Icc_self isOpen_Ioo)
Ioc_subset_closure_interior
theorem
(a b : α) : Ioc a b ⊆ closure (interior (Ioc a b))
theorem Ioc_subset_closure_interior (a b : α) : IocIoc a b ⊆ closure (interior (Ioc a b)) := by
rcases eq_or_ne a b with (rfl | h)
· simp
· calc
Ioc a b ⊆ Icc a b := Ioc_subset_Icc_self
_ = closure (Ioo a b) := (closure_Ioo h).symm
_ ⊆ closure (interior (Ioc a b)) :=
closure_mono (interior_maximal Ioo_subset_Ioc_self isOpen_Ioo)
Ico_subset_closure_interior
theorem
(a b : α) : Ico a b ⊆ closure (interior (Ico a b))
theorem Ico_subset_closure_interior (a b : α) : IcoIco a b ⊆ closure (interior (Ico a b)) := by
simpa only [Ioc_toDual] using
Ioc_subset_closure_interior (OrderDual.toDual b) (OrderDual.toDual a)
frontier_Ici'
theorem
{a : α} (ha : (Iio a).Nonempty) : frontier (Ici a) = { a }
frontier_Ici
theorem
[NoMinOrder α] {a : α} : frontier (Ici a) = { a }
theorem frontier_Ici [NoMinOrder α] {a : α} : frontier (Ici a) = {a} :=
frontier_Ici' nonempty_Iio
frontier_Iic'
theorem
{a : α} (ha : (Ioi a).Nonempty) : frontier (Iic a) = { a }
frontier_Iic
theorem
[NoMaxOrder α] {a : α} : frontier (Iic a) = { a }
theorem frontier_Iic [NoMaxOrder α] {a : α} : frontier (Iic a) = {a} :=
frontier_Iic' nonempty_Ioi
frontier_Ioi'
theorem
{a : α} (ha : (Ioi a).Nonempty) : frontier (Ioi a) = { a }
@[simp]
theorem frontier_Ioi' {a : α} (ha : (Ioi a).Nonempty) : frontier (Ioi a) = {a} := by
simp [frontier, closure_Ioi' ha, Iic_diff_Iio, Icc_self]
frontier_Ioi
theorem
[NoMaxOrder α] {a : α} : frontier (Ioi a) = { a }
theorem frontier_Ioi [NoMaxOrder α] {a : α} : frontier (Ioi a) = {a} :=
frontier_Ioi' nonempty_Ioi
frontier_Iio'
theorem
{a : α} (ha : (Iio a).Nonempty) : frontier (Iio a) = { a }
@[simp]
theorem frontier_Iio' {a : α} (ha : (Iio a).Nonempty) : frontier (Iio a) = {a} := by
simp [frontier, closure_Iio' ha, Iic_diff_Iio, Icc_self]
frontier_Iio
theorem
[NoMinOrder α] {a : α} : frontier (Iio a) = { a }
theorem frontier_Iio [NoMinOrder α] {a : α} : frontier (Iio a) = {a} :=
frontier_Iio' nonempty_Iio
frontier_Icc
theorem
[NoMinOrder α] [NoMaxOrder α] {a b : α} (h : a ≤ b) : frontier (Icc a b) = { a, b }
@[simp]
theorem frontier_Icc [NoMinOrder α] [NoMaxOrder α] {a b : α} (h : a ≤ b) :
frontier (Icc a b) = {a, b} := by simp [frontier, h, Icc_diff_Ioo_same]
frontier_Ioo
theorem
{a b : α} (h : a < b) : frontier (Ioo a b) = { a, b }
@[simp]
theorem frontier_Ioo {a b : α} (h : a < b) : frontier (Ioo a b) = {a, b} := by
rw [frontier, closure_Ioo h.ne, interior_Ioo, Icc_diff_Ioo_same h.le]
frontier_Ico
theorem
[NoMinOrder α] {a b : α} (h : a < b) : frontier (Ico a b) = { a, b }
@[simp]
theorem frontier_Ico [NoMinOrder α] {a b : α} (h : a < b) : frontier (Ico a b) = {a, b} := by
rw [frontier, closure_Ico h.ne, interior_Ico, Icc_diff_Ioo_same h.le]
frontier_Ioc
theorem
[NoMaxOrder α] {a b : α} (h : a < b) : frontier (Ioc a b) = { a, b }
@[simp]
theorem frontier_Ioc [NoMaxOrder α] {a b : α} (h : a < b) : frontier (Ioc a b) = {a, b} := by
rw [frontier, closure_Ioc h.ne, interior_Ioc, Icc_diff_Ioo_same h.le]
nhdsWithin_Ioi_neBot'
theorem
{a b : α} (H₁ : (Ioi a).Nonempty) (H₂ : a ≤ b) : NeBot (𝓝[Ioi a] b)
theorem nhdsWithin_Ioi_neBot' {a b : α} (H₁ : (Ioi a).Nonempty) (H₂ : a ≤ b) :
NeBot (𝓝[Ioi a] b) :=
mem_closure_iff_nhdsWithin_neBot.1 <| by rwa [closure_Ioi' H₁]
nhdsWithin_Ioi_neBot
theorem
[NoMaxOrder α] {a b : α} (H : a ≤ b) : NeBot (𝓝[Ioi a] b)
theorem nhdsWithin_Ioi_neBot [NoMaxOrder α] {a b : α} (H : a ≤ b) : NeBot (𝓝[Ioi a] b) :=
nhdsWithin_Ioi_neBot' nonempty_Ioi H
nhdsGT_neBot_of_exists_gt
theorem
{a : α} (H : ∃ b, a < b) : NeBot (𝓝[>] a)
theorem nhdsGT_neBot_of_exists_gt {a : α} (H : ∃ b, a < b) : NeBot (𝓝[>] a) :=
nhdsWithin_Ioi_neBot' H (le_refl a)
nhdsGT_neBot
instance
[NoMaxOrder α] (a : α) : NeBot (𝓝[>] a)
instance nhdsGT_neBot [NoMaxOrder α] (a : α) : NeBot (𝓝[>] a) := nhdsWithin_Ioi_neBot le_rfl
nhdsWithin_Ioi_self_neBot
theorem
[NoMaxOrder α] (a : α) : NeBot (𝓝[>] a)
@[deprecated nhdsGT_neBot (since := "2024-12-22")]
theorem nhdsWithin_Ioi_self_neBot [NoMaxOrder α] (a : α) : NeBot (𝓝[>] a) := nhdsGT_neBot a
nhdsWithin_Iio_neBot'
theorem
{b c : α} (H₁ : (Iio c).Nonempty) (H₂ : b ≤ c) : NeBot (𝓝[Iio c] b)
theorem nhdsWithin_Iio_neBot' {b c : α} (H₁ : (Iio c).Nonempty) (H₂ : b ≤ c) :
NeBot (𝓝[Iio c] b) :=
mem_closure_iff_nhdsWithin_neBot.1 <| by rwa [closure_Iio' H₁]
nhdsWithin_Iio_neBot
theorem
[NoMinOrder α] {a b : α} (H : a ≤ b) : NeBot (𝓝[Iio b] a)
theorem nhdsWithin_Iio_neBot [NoMinOrder α] {a b : α} (H : a ≤ b) : NeBot (𝓝[Iio b] a) :=
nhdsWithin_Iio_neBot' nonempty_Iio H
nhdsWithin_Iio_self_neBot'
theorem
{b : α} (H : (Iio b).Nonempty) : NeBot (𝓝[<] b)
theorem nhdsWithin_Iio_self_neBot' {b : α} (H : (Iio b).Nonempty) : NeBot (𝓝[<] b) :=
nhdsWithin_Iio_neBot' H (le_refl b)
nhdsLT_neBot
instance
[NoMinOrder α] (a : α) : NeBot (𝓝[<] a)
instance nhdsLT_neBot [NoMinOrder α] (a : α) : NeBot (𝓝[<] a) := nhdsWithin_Iio_neBot (le_refl a)
nhdsWithin_Iio_self_neBot
theorem
[NoMinOrder α] (a : α) : NeBot (𝓝[<] a)
@[deprecated nhdsLT_neBot (since := "2024-12-22")]
theorem nhdsWithin_Iio_self_neBot [NoMinOrder α] (a : α) : NeBot (𝓝[<] a) := nhdsLT_neBot a
right_nhdsWithin_Ico_neBot
theorem
{a b : α} (H : a < b) : NeBot (𝓝[Ico a b] b)
theorem right_nhdsWithin_Ico_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ico a b] b) :=
(isLUB_Ico H).nhdsWithin_neBot (nonempty_Ico.2 H)
left_nhdsWithin_Ioc_neBot
theorem
{a b : α} (H : a < b) : NeBot (𝓝[Ioc a b] a)
theorem left_nhdsWithin_Ioc_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ioc a b] a) :=
(isGLB_Ioc H).nhdsWithin_neBot (nonempty_Ioc.2 H)
left_nhdsWithin_Ioo_neBot
theorem
{a b : α} (H : a < b) : NeBot (𝓝[Ioo a b] a)
theorem left_nhdsWithin_Ioo_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ioo a b] a) :=
(isGLB_Ioo H).nhdsWithin_neBot (nonempty_Ioo.2 H)
right_nhdsWithin_Ioo_neBot
theorem
{a b : α} (H : a < b) : NeBot (𝓝[Ioo a b] b)
theorem right_nhdsWithin_Ioo_neBot {a b : α} (H : a < b) : NeBot (𝓝[Ioo a b] b) :=
(isLUB_Ioo H).nhdsWithin_neBot (nonempty_Ioo.2 H)
comap_coe_nhdsLT_of_Ioo_subset
theorem
(hb : s ⊆ Iio b) (hs : s.Nonempty → ∃ a < b, Ioo a b ⊆ s) : comap ((↑) : s → α) (𝓝[<] b) = atTop
theorem comap_coe_nhdsLT_of_Ioo_subset (hb : s ⊆ Iio b) (hs : s.Nonempty → ∃ a < b, Ioo a b ⊆ s) :
comap ((↑) : s → α) (𝓝[<] b) = atTop := by
nontriviality
haveI : Nonempty s := nontrivial_iff_nonempty.1 ‹_›
rcases hs (nonempty_subtype.1 ‹_›) with ⟨a, h, hs⟩
ext u; constructor
· rintro ⟨t, ht, hts⟩
obtain ⟨x, ⟨hxa : a ≤ x, hxb : x < b⟩, hxt : IooIoo x b ⊆ t⟩ :=
(mem_nhdsLT_iff_exists_mem_Ico_Ioo_subset h).mp ht
obtain ⟨y, hxy, hyb⟩ := exists_between hxb
refine mem_of_superset (mem_atTop ⟨y, hs ⟨hxa.trans_lt hxy, hyb⟩⟩) ?_
rintro ⟨z, hzs⟩ (hyz : y ≤ z)
exact hts (hxt ⟨hxy.trans_le hyz, hb hzs⟩)
· intro hu
obtain ⟨x : s, hx : ∀ z, x ≤ z → z ∈ u⟩ := mem_atTop_sets.1 hu
exact ⟨Ioo x b, Ioo_mem_nhdsLT (hb x.2), fun z hz => hx _ hz.1.le⟩
comap_coe_nhdsGT_of_Ioo_subset
theorem
(ha : s ⊆ Ioi a) (hs : s.Nonempty → ∃ b > a, Ioo a b ⊆ s) : comap ((↑) : s → α) (𝓝[>] a) = atBot
theorem comap_coe_nhdsGT_of_Ioo_subset (ha : s ⊆ Ioi a) (hs : s.Nonempty → ∃ b > a, Ioo a b ⊆ s) :
comap ((↑) : s → α) (𝓝[>] a) = atBot := by
apply comap_coe_nhdsLT_of_Ioo_subset (show ofDualofDual ⁻¹' sofDual ⁻¹' s ⊆ Iio (toDual a) from ha)
simp only [OrderDual.exists, Ioo_toDual]
exact hs
map_coe_atTop_of_Ioo_subset
theorem
(hb : s ⊆ Iio b) (hs : ∀ a' < b, ∃ a < b, Ioo a b ⊆ s) : map ((↑) : s → α) atTop = 𝓝[<] b
theorem map_coe_atTop_of_Ioo_subset (hb : s ⊆ Iio b) (hs : ∀ a' < b, ∃ a < b, Ioo a b ⊆ s) :
map ((↑) : s → α) atTop = 𝓝[<] b := by
rcases eq_empty_or_nonempty (Iio b) with (hb' | ⟨a, ha⟩)
· have : IsEmpty s := ⟨fun x => hb'.subset (hb x.2)⟩
rw [filter_eq_bot_of_isEmpty atTop, Filter.map_bot, hb', nhdsWithin_empty]
· rw [← comap_coe_nhdsLT_of_Ioo_subset hb fun _ => hs a ha, map_comap_of_mem]
rw [Subtype.range_val]
exact (mem_nhdsLT_iff_exists_Ioo_subset' ha).2 (hs a ha)
map_coe_atBot_of_Ioo_subset
theorem
(ha : s ⊆ Ioi a) (hs : ∀ b' > a, ∃ b > a, Ioo a b ⊆ s) : map ((↑) : s → α) atBot = 𝓝[>] a
theorem map_coe_atBot_of_Ioo_subset (ha : s ⊆ Ioi a) (hs : ∀ b' > a, ∃ b > a, Ioo a b ⊆ s) :
map ((↑) : s → α) atBot = 𝓝[>] a := by
-- the elaborator gets stuck without `(... :)`
refine (map_coe_atTop_of_Ioo_subset (show ofDualofDual ⁻¹' sofDual ⁻¹' s ⊆ Iio (toDual a) from ha)
fun b' hb' => ?_ :)
simpa using hs b' hb'
comap_coe_Ioo_nhdsLT
theorem
(a b : α) : comap ((↑) : Ioo a b → α) (𝓝[<] b) = atTop
/-- 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_nhdsLT (a b : α) : comap ((↑) : Ioo a b → α) (𝓝[<] b) = atTop :=
comap_coe_nhdsLT_of_Ioo_subset Ioo_subset_Iio_self fun h => ⟨a, nonempty_Ioo.1 h, Subset.refl _⟩
comap_coe_Ioo_nhdsGT
theorem
(a b : α) : comap ((↑) : Ioo a b → α) (𝓝[>] a) = atBot
/-- 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_nhdsGT (a b : α) : comap ((↑) : Ioo a b → α) (𝓝[>] a) = atBot :=
comap_coe_nhdsGT_of_Ioo_subset Ioo_subset_Ioi_self fun h => ⟨b, nonempty_Ioo.1 h, Subset.refl _⟩
comap_coe_Ioi_nhdsGT
theorem
(a : α) : comap ((↑) : Ioi a → α) (𝓝[>] a) = atBot
theorem comap_coe_Ioi_nhdsGT (a : α) : comap ((↑) : Ioi a → α) (𝓝[>] a) = atBot :=
comap_coe_nhdsGT_of_Ioo_subset (Subset.refl _) fun ⟨x, hx⟩ => ⟨x, hx, Ioo_subset_Ioi_self⟩
comap_coe_Iio_nhdsLT
theorem
(a : α) : comap ((↑) : Iio a → α) (𝓝[<] a) = atTop
theorem comap_coe_Iio_nhdsLT (a : α) : comap ((↑) : Iio a → α) (𝓝[<] a) = atTop :=
comap_coe_Ioi_nhdsGT (α := αᵒᵈ) a
map_coe_Ioo_atTop
theorem
{a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atTop = 𝓝[<] b
@[simp]
theorem map_coe_Ioo_atTop {a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atTop = 𝓝[<] b :=
map_coe_atTop_of_Ioo_subset Ioo_subset_Iio_self fun _ _ => ⟨_, h, Subset.refl _⟩
map_coe_Ioo_atBot
theorem
{a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atBot = 𝓝[>] a
@[simp]
theorem map_coe_Ioo_atBot {a b : α} (h : a < b) : map ((↑) : Ioo a b → α) atBot = 𝓝[>] a :=
map_coe_atBot_of_Ioo_subset Ioo_subset_Ioi_self fun _ _ => ⟨_, h, Subset.refl _⟩
map_coe_Ioi_atBot
theorem
(a : α) : map ((↑) : Ioi a → α) atBot = 𝓝[>] a
@[simp]
theorem map_coe_Ioi_atBot (a : α) : map ((↑) : Ioi a → α) atBot = 𝓝[>] a :=
map_coe_atBot_of_Ioo_subset (Subset.refl _) fun b hb => ⟨b, hb, Ioo_subset_Ioi_self⟩
map_coe_Iio_atTop
theorem
(a : α) : map ((↑) : Iio a → α) atTop = 𝓝[<] a
@[simp]
theorem map_coe_Iio_atTop (a : α) : map ((↑) : Iio a → α) atTop = 𝓝[<] a :=
map_coe_Ioi_atBot (α := αᵒᵈ) _
tendsto_comp_coe_Ioo_atTop
theorem
(h : a < b) : Tendsto (fun x : Ioo a b => f x) atTop l ↔ Tendsto f (𝓝[<] b) l
@[simp]
theorem tendsto_comp_coe_Ioo_atTop (h : a < b) :
TendstoTendsto (fun x : Ioo a b => f x) atTop l ↔ Tendsto f (𝓝[<] b) l := by
rw [← map_coe_Ioo_atTop h, tendsto_map'_iff]; rfl
tendsto_comp_coe_Ioo_atBot
theorem
(h : a < b) : Tendsto (fun x : Ioo a b => f x) atBot l ↔ Tendsto f (𝓝[>] a) l
@[simp]
theorem tendsto_comp_coe_Ioo_atBot (h : a < b) :
TendstoTendsto (fun x : Ioo a b => f x) atBot l ↔ Tendsto f (𝓝[>] a) l := by
rw [← map_coe_Ioo_atBot h, tendsto_map'_iff]; rfl
tendsto_comp_coe_Ioi_atBot
theorem
: Tendsto (fun x : Ioi a => f x) atBot l ↔ Tendsto f (𝓝[>] a) l
@[simp]
theorem tendsto_comp_coe_Ioi_atBot :
TendstoTendsto (fun x : Ioi a => f x) atBot l ↔ Tendsto f (𝓝[>] a) l := by
rw [← map_coe_Ioi_atBot, tendsto_map'_iff]; rfl
tendsto_comp_coe_Iio_atTop
theorem
: Tendsto (fun x : Iio a => f x) atTop l ↔ Tendsto f (𝓝[<] a) l
@[simp]
theorem tendsto_comp_coe_Iio_atTop :
TendstoTendsto (fun x : Iio a => f x) atTop l ↔ Tendsto f (𝓝[<] a) l := by
rw [← map_coe_Iio_atTop, tendsto_map'_iff]; rfl
tendsto_Ioo_atTop
theorem
{f : β → Ioo a b} : Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l (𝓝[<] b)
@[simp]
theorem tendsto_Ioo_atTop {f : β → Ioo a b} :
TendstoTendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l (𝓝[<] b) := by
rw [← comap_coe_Ioo_nhdsLT, tendsto_comap_iff]; rfl
tendsto_Ioo_atBot
theorem
{f : β → Ioo a b} : Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l (𝓝[>] a)
@[simp]
theorem tendsto_Ioo_atBot {f : β → Ioo a b} :
TendstoTendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l (𝓝[>] a) := by
rw [← comap_coe_Ioo_nhdsGT, tendsto_comap_iff]; rfl
tendsto_Ioi_atBot
theorem
{f : β → Ioi a} : Tendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l (𝓝[>] a)
@[simp]
theorem tendsto_Ioi_atBot {f : β → Ioi a} :
TendstoTendsto f l atBot ↔ Tendsto (fun x => (f x : α)) l (𝓝[>] a) := by
rw [← comap_coe_Ioi_nhdsGT, tendsto_comap_iff]; rfl
tendsto_Iio_atTop
theorem
{f : β → Iio a} : Tendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l (𝓝[<] a)
@[simp]
theorem tendsto_Iio_atTop {f : β → Iio a} :
TendstoTendsto f l atTop ↔ Tendsto (fun x => (f x : α)) l (𝓝[<] a) := by
rw [← comap_coe_Iio_nhdsLT, tendsto_comap_iff]; rfl
instNeBotNhdsWithinComplSetSingletonOfNontrivial
instance
(x : α) [Nontrivial α] : NeBot (𝓝[≠] x)
instance (x : α) [Nontrivial α] : NeBot (𝓝[≠] x) := by
refine forall_mem_nonempty_iff_neBot.1 fun s hs => ?_
obtain ⟨u, u_open, xu, us⟩ : ∃ u : Set α, IsOpen u ∧ x ∈ u ∧ u ∩ {x}ᶜ ⊆ s := mem_nhdsWithin.1 hs
obtain ⟨a, b, a_lt_b, hab⟩ : ∃ a b : α, a < b ∧ Ioo a b ⊆ u := u_open.exists_Ioo_subset ⟨x, xu⟩
obtain ⟨y, hy⟩ : ∃ y, a < y ∧ y < b := exists_between a_lt_b
rcases ne_or_eq x y with (xy | rfl)
· exact ⟨y, us ⟨hab hy, xy.symm⟩⟩
obtain ⟨z, hz⟩ : ∃ z, a < z ∧ z < x := exists_between hy.1
exact ⟨z, us ⟨hab ⟨hz.1, hz.2.trans hy.2⟩, hz.2.ne⟩⟩
Dense.exists_countable_dense_subset_no_bot_top
theorem
[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
/-- 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 := by
rcases hs.exists_countable_dense_subset with ⟨t, hts, htc, htd⟩
refine ⟨t \ ({ x | IsBot x } ∪ { x | IsTop x }), ?_, ?_, ?_, fun x hx => ?_, fun x hx => ?_⟩
· exact diff_subset.trans hts
· exact htc.mono diff_subset
· exact htd.diff_finite ((subsingleton_isBot α).finite.union (subsingleton_isTop α).finite)
· simp [hx]
· simp [hx]
exists_countable_dense_no_bot_top
theorem
[SeparableSpace α] [Nontrivial α] : ∃ s : Set α, s.Countable ∧ Dense s ∧ (∀ x, IsBot x → x ∉ s) ∧ ∀ x, IsTop x → x ∉ s
/-- 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 := by
simpa using dense_univ.exists_countable_dense_subset_no_bot_top
isClosed_Ico_iff
theorem
{a b : α} : IsClosed (Set.Ico a b) ↔ b ≤ a
/-- `Set.Ico a b` is only closed if it is empty. -/
@[simp]
theorem isClosed_Ico_iff {a b : α} : IsClosedIsClosed (Set.Ico a b) ↔ b ≤ a := by
refine ⟨fun h => le_of_not_lt fun hab => ?_, by simp_all⟩
have := h.closure_eq
rw [closure_Ico hab.ne, Icc_eq_Ico_same_iff] at this
exact this hab.le
isClosed_Ioc_iff
theorem
{a b : α} : IsClosed (Set.Ioc a b) ↔ b ≤ a
/-- `Set.Ioc a b` is only closed if it is empty. -/
@[simp]
theorem isClosed_Ioc_iff {a b : α} : IsClosedIsClosed (Set.Ioc a b) ↔ b ≤ a := by
refine ⟨fun h => le_of_not_lt fun hab => ?_, by simp_all⟩
have := h.closure_eq
rw [closure_Ioc hab.ne, Icc_eq_Ioc_same_iff] at this
exact this hab.le
isClosed_Ioo_iff
theorem
{a b : α} : IsClosed (Set.Ioo a b) ↔ b ≤ a
/-- `Set.Ioo a b` is only closed if it is empty. -/
@[simp]
theorem isClosed_Ioo_iff {a b : α} : IsClosedIsClosed (Set.Ioo a b) ↔ b ≤ a := by
refine ⟨fun h => le_of_not_lt fun hab => ?_, by simp_all⟩
have := h.closure_eq
rw [closure_Ioo hab.ne, Icc_eq_Ioo_same_iff] at this
exact this hab.le