Module docstring
{"# Neighborhoods in topological spaces
Each point x of X gets a neighborhood filter π x.
Tags
neighborhood ","### Interior, closure and frontier in terms of neighborhoods "}
{"# Neighborhoods in topological spaces
Each point x of X gets a neighborhood filter π x.
neighborhood ","### Interior, closure and frontier in terms of neighborhoods "}
nhds_def'
theorem
(x : X) : π x = β¨
(s : Set X) (_ : IsOpen s) (_ : x β s), π s
theorem nhds_def' (x : X) : π x = β¨
(s : Set X) (_ : IsOpen s) (_ : x β s), π s := by
simp only [nhds_def, mem_setOf_eq, @and_comm (x β _), iInf_and]
nhds_basis_opens
theorem
(x : X) : (π x).HasBasis (fun s : Set X => x β s β§ IsOpen s) fun s => s
/-- The open sets containing `x` are a basis for the neighborhood filter. See `nhds_basis_opens'`
for a variant using open neighborhoods instead. -/
theorem nhds_basis_opens (x : X) :
(π x).HasBasis (fun s : Set X => x β sx β s β§ IsOpen s) fun s => s := by
rw [nhds_def]
exact hasBasis_biInf_principal
(fun s β¨has, hsβ© t β¨hat, htβ© =>
β¨s β© t, β¨β¨has, hatβ©, IsOpen.inter hs htβ©, β¨inter_subset_left, inter_subset_rightβ©β©)
β¨univ, β¨mem_univ x, isOpen_univβ©β©
nhds_basis_closeds
theorem
(x : X) : (π x).HasBasis (fun s : Set X => x β s β§ IsClosed s) compl
theorem nhds_basis_closeds (x : X) : (π x).HasBasis (fun s : Set X => x β sx β s β§ IsClosed s) compl :=
β¨fun t => (nhds_basis_opens x).mem_iff.trans <|
compl_surjective.exists.trans <| by simp only [isOpen_compl_iff, mem_compl_iff]β©
lift'_nhds_interior
theorem
(x : X) : (π x).lift' interior = π x
@[simp]
theorem lift'_nhds_interior (x : X) : (π x).lift' interior = π x :=
(nhds_basis_opens x).lift'_interior_eq_self fun _ β¦ And.right
Filter.HasBasis.nhds_interior
theorem
{x : X} {p : ΞΉ β Prop} {s : ΞΉ β Set X} (h : (π x).HasBasis p s) : (π x).HasBasis p (interior <| s Β·)
theorem Filter.HasBasis.nhds_interior {x : X} {p : ΞΉ β Prop} {s : ΞΉ β Set X}
(h : (π x).HasBasis p s) : (π x).HasBasis p (interior <| s Β·) :=
lift'_nhds_interior x βΈ h.lift'_interior
le_nhds_iff
theorem
{f} : f β€ π x β β s : Set X, x β s β IsOpen s β s β f
/-- A filter lies below the neighborhood filter at `x` iff it contains every open set around `x`. -/
theorem le_nhds_iff {f} : f β€ π x β β s : Set X, x β s β IsOpen s β s β f := by simp [nhds_def]
nhds_le_of_le
theorem
{f} (h : x β s) (o : IsOpen s) (sf : π s β€ f) : π x β€ f
/-- To show a filter is above the neighborhood filter at `x`, it suffices to show that it is above
the principal filter of some open set `s` containing `x`. -/
theorem nhds_le_of_le {f} (h : x β s) (o : IsOpen s) (sf : π s β€ f) : π x β€ f := by
rw [nhds_def]; exact iInfβ_le_of_le s β¨h, oβ© sf
mem_nhds_iff
theorem
: s β π x β β t β s, IsOpen t β§ x β t
eventually_nhds_iff
theorem
{p : X β Prop} : (βαΆ y in π x, p y) β β t : Set X, (β y β t, p y) β§ IsOpen t β§ x β t
/-- A predicate is true in a neighborhood of `x` iff it is true for all the points in an open set
containing `x`. -/
theorem eventually_nhds_iff {p : X β Prop} :
(βαΆ y in π x, p y) β β t : Set X, (β y β t, p y) β§ IsOpen t β§ x β t :=
mem_nhds_iff.trans <| by simp only [subset_def, exists_prop, mem_setOf_eq]
frequently_nhds_iff
theorem
{p : X β Prop} : (βαΆ y in π x, p y) β β U : Set X, x β U β IsOpen U β β y β U, p y
theorem frequently_nhds_iff {p : X β Prop} :
(βαΆ y in π x, p y) β β U : Set X, x β U β IsOpen U β β y β U, p y :=
(nhds_basis_opens x).frequently_iff.trans <| by simp
mem_interior_iff_mem_nhds
theorem
: x β interior s β s β π x
theorem mem_interior_iff_mem_nhds : x β interior sx β interior s β s β π x :=
mem_interior.trans mem_nhds_iff.symm
map_nhds
theorem
{f : X β Ξ±} : map f (π x) = β¨
s β {s : Set X | x β s β§ IsOpen s}, π (f '' s)
theorem map_nhds {f : X β Ξ±} :
map f (π x) = β¨
s β { s : Set X | x β s β§ IsOpen s }, π (f '' s) :=
((nhds_basis_opens x).map f).eq_biInf
mem_of_mem_nhds
theorem
: s β π x β x β s
theorem mem_of_mem_nhds : s β π x β x β s := fun H =>
let β¨_t, ht, _, hsβ© := mem_nhds_iff.1 H; ht hs
Filter.Eventually.self_of_nhds
theorem
{p : X β Prop} (h : βαΆ y in π x, p y) : p x
/-- If a predicate is true in a neighborhood of `x`, then it is true for `x`. -/
theorem Filter.Eventually.self_of_nhds {p : X β Prop} (h : βαΆ y in π x, p y) : p x :=
mem_of_mem_nhds h
IsOpen.mem_nhds
theorem
(hs : IsOpen s) (hx : x β s) : s β π x
theorem IsOpen.mem_nhds (hs : IsOpen s) (hx : x β s) : s β π x :=
mem_nhds_iff.2 β¨s, Subset.refl _, hs, hxβ©
IsOpen.mem_nhds_iff
theorem
(hs : IsOpen s) : s β π x β x β s
protected theorem IsOpen.mem_nhds_iff (hs : IsOpen s) : s β π xs β π x β x β s :=
β¨mem_of_mem_nhds, fun hx => mem_nhds_iff.2 β¨s, Subset.rfl, hs, hxβ©β©
IsClosed.compl_mem_nhds
theorem
(hs : IsClosed s) (hx : x β s) : sαΆ β π x
theorem IsClosed.compl_mem_nhds (hs : IsClosed s) (hx : x β s) : sαΆsαΆ β π x :=
hs.isOpen_compl.mem_nhds (mem_compl hx)
IsOpen.eventually_mem
theorem
(hs : IsOpen s) (hx : x β s) : βαΆ x in π x, x β s
theorem IsOpen.eventually_mem (hs : IsOpen s) (hx : x β s) :
βαΆ x in π x, x β s :=
IsOpen.mem_nhds hs hx
nhds_basis_opens'
theorem
(x : X) : (π x).HasBasis (fun s : Set X => s β π x β§ IsOpen s) fun x => x
/-- The open neighborhoods of `x` are a basis for the neighborhood filter. See `nhds_basis_opens`
for a variant using open sets around `x` instead. -/
theorem nhds_basis_opens' (x : X) :
(π x).HasBasis (fun s : Set X => s β π xs β π x β§ IsOpen s) fun x => x := by
convert nhds_basis_opens x using 2
exact and_congr_left_iff.2 IsOpen.mem_nhds_iff
exists_open_set_nhds
theorem
{U : Set X} (h : β x β s, U β π x) : β V : Set X, s β V β§ IsOpen V β§ V β U
/-- If `U` is a neighborhood of each point of a set `s` then it is a neighborhood of `s`:
it contains an open set containing `s`. -/
theorem exists_open_set_nhds {U : Set X} (h : β x β s, U β π x) :
β V : Set X, s β V β§ IsOpen V β§ V β U :=
β¨interior U, fun x hx => mem_interior_iff_mem_nhds.2 <| h x hx, isOpen_interior, interior_subsetβ©
exists_open_set_nhds'
theorem
{U : Set X} (h : U β β¨ x β s, π x) : β V : Set X, s β V β§ IsOpen V β§ V β U
/-- If `U` is a neighborhood of each point of a set `s` then it is a neighborhood of s:
it contains an open set containing `s`. -/
theorem exists_open_set_nhds' {U : Set X} (h : U β β¨ x β s, π x) :
β V : Set X, s β V β§ IsOpen V β§ V β U :=
exists_open_set_nhds (by simpa using h)
Filter.Eventually.eventually_nhds
theorem
{p : X β Prop} (h : βαΆ y in π x, p y) : βαΆ y in π x, βαΆ x in π y, p x
/-- If a predicate is true in a neighbourhood of `x`, then for `y` sufficiently close
to `x` this predicate is true in a neighbourhood of `y`. -/
theorem Filter.Eventually.eventually_nhds {p : X β Prop} (h : βαΆ y in π x, p y) :
βαΆ y in π x, βαΆ x in π y, p x :=
let β¨t, htp, hto, haβ© := eventually_nhds_iff.1 h
eventually_nhds_iff.2 β¨t, fun _x hx => eventually_nhds_iff.2 β¨t, htp, hto, hxβ©, hto, haβ©
eventually_eventually_nhds
theorem
{p : X β Prop} : (βαΆ y in π x, βαΆ x in π y, p x) β βαΆ x in π x, p x
@[simp]
theorem eventually_eventually_nhds {p : X β Prop} :
(βαΆ y in π x, βαΆ x in π y, p x) β βαΆ x in π x, p x :=
β¨fun h => h.self_of_nhds, fun h => h.eventually_nhdsβ©
frequently_frequently_nhds
theorem
{p : X β Prop} : (βαΆ x' in π x, βαΆ x'' in π x', p x'') β βαΆ x in π x, p x
@[simp]
theorem frequently_frequently_nhds {p : X β Prop} :
(βαΆ x' in π x, βαΆ x'' in π x', p x'') β βαΆ x in π x, p x := by
rw [β not_iff_not]
simp only [not_frequently, eventually_eventually_nhds]
eventually_mem_nhds_iff
theorem
: (βαΆ x' in π x, s β π x') β s β π x
@[simp]
theorem eventually_mem_nhds_iff : (βαΆ x' in π x, s β π x') β s β π x :=
eventually_eventually_nhds
nhds_bind_nhds
theorem
: (π x).bind π = π x
@[simp]
theorem nhds_bind_nhds : (π x).bind π = π x :=
Filter.ext fun _ => eventually_eventually_nhds
eventually_eventuallyEq_nhds
theorem
{f g : X β Ξ±} : (βαΆ y in π x, f =αΆ [π y] g) β f =αΆ [π x] g
@[simp]
theorem eventually_eventuallyEq_nhds {f g : X β Ξ±} :
(βαΆ y in π x, f =αΆ [π y] g) β f =αΆ [π x] g :=
eventually_eventually_nhds
eventually_eventuallyLE_nhds
theorem
[LE Ξ±] {f g : X β Ξ±} : (βαΆ y in π x, f β€αΆ [π y] g) β f β€αΆ [π x] g
@[simp]
theorem eventually_eventuallyLE_nhds [LE Ξ±] {f g : X β Ξ±} :
(βαΆ y in π x, f β€αΆ [π y] g) β f β€αΆ [π x] g :=
eventually_eventually_nhds
Filter.EventuallyEq.eventuallyEq_nhds
theorem
{f g : X β Ξ±} (h : f =αΆ [π x] g) : βαΆ y in π x, f =αΆ [π y] g
/-- If two functions are equal in a neighbourhood of `x`, then for `y` sufficiently close
to `x` these functions are equal in a neighbourhood of `y`. -/
theorem Filter.EventuallyEq.eventuallyEq_nhds {f g : X β Ξ±} (h : f =αΆ [π x] g) :
βαΆ y in π x, f =αΆ [π y] g :=
h.eventually_nhds
Filter.EventuallyLE.eventuallyLE_nhds
theorem
[LE Ξ±] {f g : X β Ξ±} (h : f β€αΆ [π x] g) : βαΆ y in π x, f β€αΆ [π y] g
/-- If `f x β€ g x` in a neighbourhood of `x`, then for `y` sufficiently close to `x` we have
`f x β€ g x` in a neighbourhood of `y`. -/
theorem Filter.EventuallyLE.eventuallyLE_nhds [LE Ξ±] {f g : X β Ξ±} (h : f β€αΆ [π x] g) :
βαΆ y in π x, f β€αΆ [π y] g :=
h.eventually_nhds
all_mem_nhds
theorem
(x : X) (P : Set X β Prop) (hP : β s t, s β t β P s β P t) : (β s β π x, P s) β β s, IsOpen s β x β s β P s
theorem all_mem_nhds (x : X) (P : Set X β Prop) (hP : β s t, s β t β P s β P t) :
(β s β π x, P s) β β s, IsOpen s β x β s β P s :=
((nhds_basis_opens x).forall_iff hP).trans <| by simp only [@and_comm (x β _), and_imp]
all_mem_nhds_filter
theorem
(x : X) (f : Set X β Set Ξ±) (hf : β s t, s β t β f s β f t) (l : Filter Ξ±) :
(β s β π x, f s β l) β β s, IsOpen s β x β s β f s β l
theorem all_mem_nhds_filter (x : X) (f : Set X β Set Ξ±) (hf : β s t, s β t β f s β f t)
(l : Filter Ξ±) : (β s β π x, f s β l) β β s, IsOpen s β x β s β f s β l :=
all_mem_nhds _ _ fun s t ssubt h => mem_of_superset h (hf s t ssubt)
tendsto_nhds
theorem
{f : Ξ± β X} {l : Filter Ξ±} : Tendsto f l (π x) β β s, IsOpen s β x β s β f β»ΒΉ' s β l
theorem tendsto_nhds {f : Ξ± β X} {l : Filter Ξ±} :
TendstoTendsto f l (π x) β β s, IsOpen s β x β s β f β»ΒΉ' s β l :=
all_mem_nhds_filter _ _ (fun _ _ h => preimage_mono h) _
tendsto_atTop_nhds
theorem
[Nonempty Ξ±] [SemilatticeSup Ξ±] {f : Ξ± β X} :
Tendsto f atTop (π x) β β U : Set X, x β U β IsOpen U β β N, β n, N β€ n β f n β U
theorem tendsto_atTop_nhds [Nonempty Ξ±] [SemilatticeSup Ξ±] {f : Ξ± β X} :
TendstoTendsto f atTop (π x) β β U : Set X, x β U β IsOpen U β β N, β n, N β€ n β f n β U :=
(atTop_basis.tendsto_iff (nhds_basis_opens x)).trans <| by
simp only [and_imp, exists_prop, true_and, mem_Ici]
tendsto_const_nhds
theorem
{f : Filter Ξ±} : Tendsto (fun _ : Ξ± => x) f (π x)
theorem tendsto_const_nhds {f : Filter Ξ±} : Tendsto (fun _ : Ξ± => x) f (π x) :=
tendsto_nhds.mpr fun _ _ ha => univ_mem' fun _ => ha
tendsto_atTop_of_eventually_const
theorem
{ΞΉ : Type*} [Preorder ΞΉ] {u : ΞΉ β X} {iβ : ΞΉ} (h : β i β₯ iβ, u i = x) : Tendsto u atTop (π x)
theorem tendsto_atTop_of_eventually_const {ΞΉ : Type*} [Preorder ΞΉ]
{u : ΞΉ β X} {iβ : ΞΉ} (h : β i β₯ iβ, u i = x) : Tendsto u atTop (π x) :=
Tendsto.congr' (EventuallyEq.symm ((eventually_ge_atTop iβ).mono h)) tendsto_const_nhds
tendsto_atBot_of_eventually_const
theorem
{ΞΉ : Type*} [Preorder ΞΉ] {u : ΞΉ β X} {iβ : ΞΉ} (h : β i β€ iβ, u i = x) : Tendsto u atBot (π x)
theorem tendsto_atBot_of_eventually_const {ΞΉ : Type*} [Preorder ΞΉ]
{u : ΞΉ β X} {iβ : ΞΉ} (h : β i β€ iβ, u i = x) : Tendsto u atBot (π x) :=
tendsto_atTop_of_eventually_const (ΞΉ := ΞΉα΅α΅) h
pure_le_nhds
theorem
: pure β€ (π : X β Filter X)
theorem pure_le_nhds : pure β€ (π : X β Filter X) := fun _ _ hs => mem_pure.2 <| mem_of_mem_nhds hs
tendsto_pure_nhds
theorem
(f : Ξ± β X) (a : Ξ±) : Tendsto f (pure a) (π (f a))
theorem tendsto_pure_nhds (f : Ξ± β X) (a : Ξ±) : Tendsto f (pure a) (π (f a)) :=
(tendsto_pure_pure f a).mono_right (pure_le_nhds _)
OrderTop.tendsto_atTop_nhds
theorem
[PartialOrder Ξ±] [OrderTop Ξ±] (f : Ξ± β X) : Tendsto f atTop (π (f β€))
theorem OrderTop.tendsto_atTop_nhds [PartialOrder Ξ±] [OrderTop Ξ±] (f : Ξ± β X) :
Tendsto f atTop (π (f β€)) :=
(tendsto_atTop_pure f).mono_right (pure_le_nhds _)
nhds_neBot
instance
: NeBot (π x)
@[simp]
instance nhds_neBot : NeBot (π x) :=
neBot_of_le (pure_le_nhds x)
tendsto_nhds_of_eventually_eq
theorem
{l : Filter Ξ±} {f : Ξ± β X} (h : βαΆ x' in l, f x' = x) : Tendsto f l (π x)
theorem tendsto_nhds_of_eventually_eq {l : Filter Ξ±} {f : Ξ± β X} (h : βαΆ x' in l, f x' = x) :
Tendsto f l (π x) :=
tendsto_const_nhds.congr' (.symm h)
Filter.EventuallyEq.tendsto
theorem
{l : Filter Ξ±} {f : Ξ± β X} (hf : f =αΆ [l] fun _ β¦ x) : Tendsto f l (π x)
theorem Filter.EventuallyEq.tendsto {l : Filter Ξ±} {f : Ξ± β X} (hf : f =αΆ [l] fun _ β¦ x) :
Tendsto f l (π x) :=
tendsto_nhds_of_eventually_eq hf
interior_eq_nhds'
theorem
: interior s = {x | s β π x}
theorem interior_eq_nhds' : interior s = { x | s β π x } :=
Set.ext fun x => by simp only [mem_interior, mem_nhds_iff, mem_setOf_eq]
interior_eq_nhds
theorem
: interior s = {x | π x β€ π s}
theorem interior_eq_nhds : interior s = { x | π x β€ π s } :=
interior_eq_nhds'.trans <| by simp only [le_principal_iff]
interior_mem_nhds
theorem
: interior s β π x β s β π x
interior_setOf_eq
theorem
{p : X β Prop} : interior {x | p x} = {x | βαΆ y in π x, p y}
theorem interior_setOf_eq {p : X β Prop} : interior { x | p x } = { x | βαΆ y in π x, p y } :=
interior_eq_nhds'
isOpen_setOf_eventually_nhds
theorem
{p : X β Prop} : IsOpen {x | βαΆ y in π x, p y}
theorem isOpen_setOf_eventually_nhds {p : X β Prop} : IsOpen { x | βαΆ y in π x, p y } := by
simp only [β interior_setOf_eq, isOpen_interior]
subset_interior_iff_nhds
theorem
{V : Set X} : s β interior V β β x β s, V β π x
theorem subset_interior_iff_nhds {V : Set X} : s β interior Vs β interior V β β x β s, V β π x := by
simp_rw [subset_def, mem_interior_iff_mem_nhds]
isOpen_iff_nhds
theorem
: IsOpen s β β x β s, π x β€ π s
TopologicalSpace.ext_iff_nhds
theorem
{X} {t t' : TopologicalSpace X} : t = t' β β x, @nhds _ t x = @nhds _ t' x
isOpen_iff_mem_nhds
theorem
: IsOpen s β β x β s, s β π x
theorem isOpen_iff_mem_nhds : IsOpenIsOpen s β β x β s, s β π x :=
isOpen_iff_nhds.trans <| forall_congr' fun _ => imp_congr_right fun _ => le_principal_iff
isOpen_iff_eventually
theorem
: IsOpen s β β x, x β s β βαΆ y in π x, y β s
/-- A set `s` is open iff for every point `x` in `s` and every `y` close to `x`, `y` is in `s`. -/
theorem isOpen_iff_eventually : IsOpenIsOpen s β β x, x β s β βαΆ y in π x, y β s :=
isOpen_iff_mem_nhds
isOpen_singleton_iff_nhds_eq_pure
theorem
(x : X) : IsOpen ({ x } : Set X) β π x = pure x
theorem isOpen_singleton_iff_nhds_eq_pure (x : X) : IsOpenIsOpen ({x} : Set X) β π x = pure x := by
simp [β (pure_le_nhds _).le_iff_eq, isOpen_iff_mem_nhds]
isOpen_singleton_iff_punctured_nhds
theorem
(x : X) : IsOpen ({ x } : Set X) β π[β ] x = β₯
theorem isOpen_singleton_iff_punctured_nhds (x : X) : IsOpenIsOpen ({x} : Set X) β π[β ] x = β₯ := by
rw [isOpen_singleton_iff_nhds_eq_pure, nhdsWithin, β mem_iff_inf_principal_compl,
le_antisymm_iff]
simp [pure_le_nhds x]
mem_closure_iff_frequently
theorem
: x β closure s β βαΆ x in π x, x β s
isClosed_iff_frequently
theorem
: IsClosed s β β x, (βαΆ y in π x, y β s) β x β s
/-- A set `s` is closed iff for every point `x`, if there is a point `y` close to `x` that belongs
to `s` then `x` is in `s`. -/
theorem isClosed_iff_frequently : IsClosedIsClosed s β β x, (βαΆ y in π x, y β s) β x β s := by
rw [β closure_subset_iff_isClosed]
refine forall_congr' fun x => ?_
rw [mem_closure_iff_frequently]
nhdsWithin_neBot
theorem
: (π[s] x).NeBot β β β¦tβ¦, t β π x β (t β© s).Nonempty
nhdsWithin_mono
theorem
(x : X) {s t : Set X} (h : s β t) : π[s] x β€ π[t] x
@[gcongr]
theorem nhdsWithin_mono (x : X) {s t : Set X} (h : s β t) : π[s] x β€ π[t] x :=
inf_le_inf_left _ (principal_mono.mpr h)
IsClosed.interior_union_left
theorem
(_ : IsClosed s) : interior (s βͺ t) β s βͺ interior t
theorem IsClosed.interior_union_left (_ : IsClosed s) :
interiorinterior (s βͺ t) β s βͺ interior t := fun a β¨u, β¨β¨huβ, huββ©, haβ©β© =>
(Classical.em (a β s)).imp_right fun h =>
mem_interior.mpr
β¨u β© sαΆ, fun _x hx => (huβ hx.1).resolve_left hx.2, IsOpen.inter huβ IsClosed.isOpen_compl,
β¨ha, hβ©β©
IsClosed.interior_union_right
theorem
(h : IsClosed t) : interior (s βͺ t) β interior s βͺ t
theorem IsClosed.interior_union_right (h : IsClosed t) :
interiorinterior (s βͺ t) β interior s βͺ t := by
simpa only [union_comm _ t] using h.interior_union_left
IsOpen.inter_closure
theorem
(h : IsOpen s) : s β© closure t β closure (s β© t)
theorem IsOpen.inter_closure (h : IsOpen s) : s β© closure ts β© closure t β closure (s β© t) :=
compl_subset_compl.mp <| by
simpa only [β interior_compl, compl_inter] using IsClosed.interior_union_left h.isClosed_compl
IsOpen.closure_inter
theorem
(h : IsOpen t) : closure s β© t β closure (s β© t)
theorem IsOpen.closure_inter (h : IsOpen t) : closureclosure s β© tclosure s β© t β closure (s β© t) := by
simpa only [inter_comm t] using h.inter_closure
Dense.open_subset_closure_inter
theorem
(hs : Dense s) (ht : IsOpen t) : t β closure (t β© s)
theorem Dense.open_subset_closure_inter (hs : Dense s) (ht : IsOpen t) :
t β closure (t β© s) :=
calc
t = t β© closure s := by rw [hs.closure_eq, inter_univ]
_ β closure (t β© s) := ht.inter_closure
Dense.inter_of_isOpen_left
theorem
(hs : Dense s) (ht : Dense t) (hso : IsOpen s) : Dense (s β© t)
/-- The intersection of an open dense set with a dense set is a dense set. -/
theorem Dense.inter_of_isOpen_left (hs : Dense s) (ht : Dense t) (hso : IsOpen s) :
Dense (s β© t) := fun x =>
closure_minimal hso.inter_closure isClosed_closure <| by simp [hs.closure_eq, ht.closure_eq]
Dense.inter_of_isOpen_right
theorem
(hs : Dense s) (ht : Dense t) (hto : IsOpen t) : Dense (s β© t)
/-- The intersection of a dense set with an open dense set is a dense set. -/
theorem Dense.inter_of_isOpen_right (hs : Dense s) (ht : Dense t) (hto : IsOpen t) :
Dense (s β© t) :=
inter_comm t s βΈ ht.inter_of_isOpen_left hs hto
Dense.inter_nhds_nonempty
theorem
(hs : Dense s) (ht : t β π x) : (s β© t).Nonempty
theorem Dense.inter_nhds_nonempty (hs : Dense s) (ht : t β π x) :
(s β© t).Nonempty :=
let β¨U, hsub, ho, hxβ© := mem_nhds_iff.1 ht
(hs.inter_open_nonempty U ho β¨x, hxβ©).mono fun _y hy => β¨hy.2, hsub hy.1β©
closure_diff
theorem
: closure s \ closure t β closure (s \ t)
theorem closure_diff : closureclosure s \ closure tclosure s \ closure t β closure (s \ t) :=
calc
closure s \ closure t = (closure t)αΆ β© closure s := by simp only [diff_eq, inter_comm]
_ β closure ((closure t)αΆ β© s)calc
closure s \ closure t = (closure t)αΆ β© closure s := by simp only [diff_eq, inter_comm]
_ β closure ((closure t)αΆ β© s) := (isOpen_compl_iff.mpr <| isClosed_closure).inter_closure
_ = closure (s \ closure t) := by simp only [diff_eq, inter_comm]
_ β closure (s \ t) := closure_mono <| diff_subset_diff (Subset.refl s) subset_closure
Filter.Frequently.mem_of_closed
theorem
(h : βαΆ x in π x, x β s) (hs : IsClosed s) : x β s
theorem Filter.Frequently.mem_of_closed (h : βαΆ x in π x, x β s)
(hs : IsClosed s) : x β s :=
hs.closure_subset h.mem_closure
IsClosed.mem_of_frequently_of_tendsto
theorem
{f : Ξ± β X} {b : Filter Ξ±} (hs : IsClosed s) (h : βαΆ x in b, f x β s) (hf : Tendsto f b (π x)) : x β s
theorem IsClosed.mem_of_frequently_of_tendsto {f : Ξ± β X} {b : Filter Ξ±}
(hs : IsClosed s) (h : βαΆ x in b, f x β s) (hf : Tendsto f b (π x)) : x β s :=
(hf.frequently <| show βαΆ x in b, (fun y => y β s) (f x) from h).mem_of_closed hs
IsClosed.mem_of_tendsto
theorem
{f : Ξ± β X} {b : Filter Ξ±} [NeBot b] (hs : IsClosed s) (hf : Tendsto f b (π x)) (h : βαΆ x in b, f x β s) : x β s
theorem IsClosed.mem_of_tendsto {f : Ξ± β X} {b : Filter Ξ±} [NeBot b]
(hs : IsClosed s) (hf : Tendsto f b (π x)) (h : βαΆ x in b, f x β s) : x β s :=
hs.mem_of_frequently_of_tendsto h.frequently hf
mem_closure_of_frequently_of_tendsto
theorem
{f : Ξ± β X} {b : Filter Ξ±} (h : βαΆ x in b, f x β s) (hf : Tendsto f b (π x)) : x β closure s
theorem mem_closure_of_frequently_of_tendsto {f : Ξ± β X} {b : Filter Ξ±}
(h : βαΆ x in b, f x β s) (hf : Tendsto f b (π x)) : x β closure s :=
(hf.frequently h).mem_closure
mem_closure_of_tendsto
theorem
{f : Ξ± β X} {b : Filter Ξ±} [NeBot b] (hf : Tendsto f b (π x)) (h : βαΆ x in b, f x β s) : x β closure s
theorem mem_closure_of_tendsto {f : Ξ± β X} {b : Filter Ξ±} [NeBot b]
(hf : Tendsto f b (π x)) (h : βαΆ x in b, f x β s) : x β closure s :=
mem_closure_of_frequently_of_tendsto h.frequently hf
tendsto_inf_principal_nhds_iff_of_forall_eq
theorem
{f : Ξ± β X} {l : Filter Ξ±} {s : Set Ξ±} (h : β a β s, f a = x) : Tendsto f (l β π s) (π x) β Tendsto f l (π x)
/-- Suppose that `f` sends the complement to `s` to a single point `x`, and `l` is some filter.
Then `f` tends to `x` along `l` restricted to `s` if and only if it tends to `x` along `l`. -/
theorem tendsto_inf_principal_nhds_iff_of_forall_eq {f : Ξ± β X} {l : Filter Ξ±} {s : Set Ξ±}
(h : β a β s, f a = x) : TendstoTendsto f (l β π s) (π x) β Tendsto f l (π x) := by
rw [tendsto_iff_comap, tendsto_iff_comap]
replace h : π sαΆ β€ comap f (π x) := by
rintro U β¨t, ht, htUβ© x hx
have : f x β t := (h x hx).symm βΈ mem_of_mem_nhds ht
exact htU this
refine β¨fun h' => ?_, le_trans inf_le_leftβ©
have := sup_le h' h
rw [sup_inf_right, sup_principal, union_compl_self, principal_univ, inf_top_eq, sup_le_iff]
at this
exact this.1