statement stringlengths 1 2.93k | proof stringlengths 0 19.2k | type stringclasses 13
values | symbolic_name stringlengths 1 131 | library stringlengths 4 62 | filename stringlengths 20 95 | imports listlengths 0 10 | deps listlengths 0 64 | docstring stringlengths 0 4.95k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
exists_clopen_of_closed_subset_open {X : Type*}
[TopologicalSpace X] [CompactSpace X] [T2Space X] [TotallyDisconnectedSpace X]
{Z U : Set X} (hZ : IsClosed Z) (hU : IsOpen U) (hZU : Z ⊆ U) :
∃ C : Set X, IsClopen C ∧ Z ⊆ C ∧ C ⊆ U | by
-- every `z ∈ Z` has clopen neighborhood `V z ⊆ U`
choose V hV using fun (z : Z) ↦ compact_exists_isClopen_in_isOpen hU (hZU z.property)
-- the `V z` cover `Z`
have V_cover : Z ⊆ ⋃ z, V z := fun z hz ↦ mem_iUnion.mpr ⟨⟨z, hz⟩, (hV ⟨z, hz⟩).2.1⟩
-- choose a finite subcover
choose I hI using hZ.isCompact.e... | lemma | exists_clopen_of_closed_subset_open | Topology.Separation | Mathlib/Topology/Separation/Profinite.lean | [] | [
"CompactSpace",
"IsClopen",
"IsClosed",
"IsOpen",
"Set",
"T2Space",
"TopologicalSpace",
"TotallyDisconnectedSpace",
"compact_exists_isClopen_in_isOpen"
] | In a totally disconnected compact Hausdorff space `X`, if `Z ⊆ U` are subsets with `Z` closed
and `U` open, there exists a clopen `C` with `Z ⊆ C ⊆ U`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
exists_clopen_partition_of_clopen_cover
{X I : Type*} [TopologicalSpace X] [CompactSpace X] [T2Space X] [TotallyDisconnectedSpace X]
[Finite I] {Z D : I → Set X}
(Z_closed : ∀ i, IsClosed (Z i)) (D_clopen : ∀ i, IsClopen (D i))
(Z_subset_D : ∀ i, Z i ⊆ D i) (Z_disj : univ.PairwiseDisjoint Z) :
∃ C :... | by
induction I using Finite.induction_empty_option with
| of_equiv e IH =>
obtain ⟨C, h1, h2, h3, h4, h5⟩ := IH (Z := Z ∘ e) (D := D ∘ e)
(fun i ↦ Z_closed (e i)) (fun i ↦ D_clopen (e i))
(fun i ↦ Z_subset_D (e i)) (by simpa [← e.injective.injOn.pairwiseDisjoint_image])
refine ⟨C ∘ e.symm, fun i... | lemma | exists_clopen_partition_of_clopen_cover | Topology.Separation | Mathlib/Topology/Separation/Profinite.lean | [] | [
"CompactSpace",
"Disjoint.mono_left",
"Disjoint.mono_right",
"Finite",
"Finite.induction_empty_option",
"IsClopen",
"IsClosed",
"IsOpen",
"IsOpen.sdiff",
"Option.some_injective",
"Set",
"Set.disjoint_iff_inter_eq_empty",
"Set.not_nonempty_iff_eq_empty",
"Set.pairwiseDisjoint_iff",
"T2Spa... | Let `X` be a totally disconnected compact Hausdorff space, `D i ⊆ X` a finite family of clopens,
and `Z i ⊆ D i` closed. Assume that the `Z i` are pairwise disjoint. Then there exist clopens
`Z i ⊆ C i ⊆ D i` with the `C i` disjoint, and such that `∪ D i ⊆ ∪ C i`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
RegularSpace (X : Type u) [TopologicalSpace X] : Prop where
/-- If `a` is a point that does not belong to a closed set `s`, then `a` and `s` admit disjoint
neighborhoods. -/
regular : ∀ {s : Set X} {a}, IsClosed s → a ∉ s → Disjoint (𝓝ˢ s) (𝓝 a) | class | RegularSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsClosed",
"Set",
"TopologicalSpace"
] | A topological space is called a *regular space* if for any closed set `s` and `a ∉ s`, there
exist disjoint open sets `U ⊇ s` and `V ∋ a`. We formulate this condition in terms of `Disjoint`ness
of filters `𝓝ˢ s` and `𝓝 a`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
regularSpace_TFAE (X : Type u) [TopologicalSpace X] :
List.TFAE [RegularSpace X,
∀ (s : Set X) x, x ∉ closure s → Disjoint (𝓝ˢ s) (𝓝 x),
∀ (x : X) (s : Set X), Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s,
∀ (x : X) (s : Set X), s ∈ 𝓝 x → ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s,
∀ x : X, (𝓝 x).lift' c... | by
tfae_have 1 ↔ 5 := by
rw [regularSpace_iff, (@compl_surjective (Set X) _).forall, forall_comm]
simp only [isClosed_compl_iff, mem_compl_iff, Classical.not_not, @and_comm (_ ∈ _),
(nhds_basis_opens _).lift'_closure.le_basis_iff (nhds_basis_opens _), and_imp,
(nhds_basis_opens _).disjoint_iff_rig... | theorem | regularSpace_TFAE | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsClosed",
"List.TFAE",
"RegularSpace",
"Set",
"TopologicalSpace",
"antisymm",
"closure",
"compl_surjective",
"disjoint_compl_left",
"interior_compl",
"isClosed_closure",
"isClosed_compl_iff",
"mem_interior_iff_mem_nhds",
"nhds_basis_opens",
"principal_le_nhdsSet",
"subs... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
RegularSpace.of_lift'_closure_le (h : ∀ x : X, (𝓝 x).lift' closure ≤ 𝓝 x) :
RegularSpace X | Iff.mpr ((regularSpace_TFAE X).out 0 4) h | theorem | RegularSpace.of_lift'_closure_le | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace",
"closure",
"regularSpace_TFAE"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
RegularSpace.of_lift'_closure (h : ∀ x : X, (𝓝 x).lift' closure = 𝓝 x) : RegularSpace X | Iff.mpr ((regularSpace_TFAE X).out 0 5) h | theorem | RegularSpace.of_lift'_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace",
"closure",
"regularSpace_TFAE"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
RegularSpace.of_hasBasis {ι : X → Sort*} {p : ∀ a, ι a → Prop} {s : ∀ a, ι a → Set X}
(h₁ : ∀ a, (𝓝 a).HasBasis (p a) (s a)) (h₂ : ∀ a i, p a i → IsClosed (s a i)) :
RegularSpace X | .of_lift'_closure fun a => (h₁ a).lift'_closure_eq_self (h₂ a) | theorem | RegularSpace.of_hasBasis | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"RegularSpace",
"Set"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
RegularSpace.of_exists_mem_nhds_isClosed_subset
(h : ∀ (x : X), ∀ s ∈ 𝓝 x, ∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s) : RegularSpace X | Iff.mpr ((regularSpace_TFAE X).out 0 3) h | theorem | RegularSpace.of_exists_mem_nhds_isClosed_subset | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"RegularSpace",
"regularSpace_TFAE"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
regularSpace_generateFrom {s : Set (Set X)} (h : ‹_› = generateFrom s) :
RegularSpace X ↔ ∀ t ∈ s, ∀ a ∈ t, Disjoint (𝓝ˢ tᶜ) (𝓝 a) | by
refine ⟨fun _ t ht a ha => RegularSpace.regular
(h ▸ isOpen_generateFrom_of_mem ht).isClosed_compl
(Set.notMem_compl_iff.mpr ha), fun h' => ⟨fun {t a} ht ha => ?_⟩⟩
obtain ⟨t, rfl⟩ := compl_involutive.surjective t
rw [isClosed_compl_iff, h] at ht
rw [Set.notMem_compl_iff] at ha
induction ht with
... | theorem | regularSpace_generateFrom | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"RegularSpace",
"Set",
"Set.notMem_compl_iff",
"disjoint_sup_left",
"isClosed_compl_iff",
"nhdsSet_union"
] | Given a subbasis `s`, it is enough to check the condition of regularity for complements of sets
in `s`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
disjoint_nhdsSet_nhds : Disjoint (𝓝ˢ s) (𝓝 x) ↔ x ∉ closure s | by
have h := (regularSpace_TFAE X).out 0 2
exact h.mp ‹_› _ _ | theorem | disjoint_nhdsSet_nhds | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"closure",
"regularSpace_TFAE"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
disjoint_nhds_nhdsSet : Disjoint (𝓝 x) (𝓝ˢ s) ↔ x ∉ closure s | disjoint_comm.trans disjoint_nhdsSet_nhds | theorem | disjoint_nhds_nhdsSet | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"closure",
"disjoint_nhdsSet_nhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
exists_mem_nhds_isClosed_subset {x : X} {s : Set X} (h : s ∈ 𝓝 x) :
∃ t ∈ 𝓝 x, IsClosed t ∧ t ⊆ s | by
have h' := (regularSpace_TFAE X).out 0 3
exact h'.mp ‹_› _ _ h | theorem | exists_mem_nhds_isClosed_subset | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"Set",
"regularSpace_TFAE"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
closed_nhds_basis (x : X) : (𝓝 x).HasBasis (fun s : Set X => s ∈ 𝓝 x ∧ IsClosed s) id | hasBasis_self.2 fun _ => exists_mem_nhds_isClosed_subset | theorem | closed_nhds_basis | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"Set",
"exists_mem_nhds_isClosed_subset"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
lift'_nhds_closure (x : X) : (𝓝 x).lift' closure = 𝓝 x | (closed_nhds_basis x).lift'_closure_eq_self fun _ => And.right | theorem | lift'_nhds_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"closed_nhds_basis",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Filter.HasBasis.nhds_closure {ι : Sort*} {x : X} {p : ι → Prop} {s : ι → Set X}
(h : (𝓝 x).HasBasis p s) : (𝓝 x).HasBasis p fun i => closure (s i) | lift'_nhds_closure x ▸ h.lift'_closure | theorem | Filter.HasBasis.nhds_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Set",
"closure",
"lift'_nhds_closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
hasBasis_nhds_closure (x : X) : (𝓝 x).HasBasis (fun s => s ∈ 𝓝 x) closure | (𝓝 x).basis_sets.nhds_closure | theorem | hasBasis_nhds_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
hasBasis_opens_closure (x : X) : (𝓝 x).HasBasis (fun s => x ∈ s ∧ IsOpen s) closure | (nhds_basis_opens x).nhds_closure | theorem | hasBasis_opens_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsOpen",
"closure",
"nhds_basis_opens"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsCompact.exists_isOpen_closure_subset {K U : Set X} (hK : IsCompact K) (hU : U ∈ 𝓝ˢ K) :
∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U | by
have hd : Disjoint (𝓝ˢ K) (𝓝ˢ Uᶜ) := by
simpa [hK.disjoint_nhdsSet_left, disjoint_nhds_nhdsSet,
← subset_interior_iff_mem_nhdsSet] using! hU
rcases ((hasBasis_nhdsSet _).disjoint_iff (hasBasis_nhdsSet _)).1 hd
with ⟨V, ⟨hVo, hKV⟩, W, ⟨hW, hUW⟩, hVW⟩
refine ⟨V, hVo, hKV, Subset.trans ?_ (compl_s... | theorem | IsCompact.exists_isOpen_closure_subset | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsCompact",
"IsOpen",
"Set",
"closure",
"closure_minimal",
"disjoint_iff",
"disjoint_nhds_nhdsSet",
"hasBasis_nhdsSet",
"subset_interior_iff_mem_nhdsSet"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
IsCompact.lift'_closure_nhdsSet {K : Set X} (hK : IsCompact K) :
(𝓝ˢ K).lift' closure = 𝓝ˢ K | by
refine le_antisymm (fun U hU ↦ ?_) (le_lift'_closure _)
rcases hK.exists_isOpen_closure_subset hU with ⟨V, hVo, hKV, hVU⟩
exact mem_of_superset (mem_lift' <| hVo.mem_nhdsSet.2 hKV) hVU | theorem | IsCompact.lift'_closure_nhdsSet | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsCompact",
"Set",
"closure",
"le_antisymm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
TopologicalSpace.IsTopologicalBasis.nhds_basis_closure {B : Set (Set X)}
(hB : IsTopologicalBasis B) (x : X) :
(𝓝 x).HasBasis (fun s : Set X => x ∈ s ∧ s ∈ B) closure | by
simpa only [and_comm] using hB.nhds_hasBasis.nhds_closure | theorem | TopologicalSpace.IsTopologicalBasis.nhds_basis_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Set",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
TopologicalSpace.IsTopologicalBasis.exists_closure_subset {B : Set (Set X)}
(hB : IsTopologicalBasis B) {x : X} {s : Set X} (h : s ∈ 𝓝 x) :
∃ t ∈ B, x ∈ t ∧ closure t ⊆ s | by
simpa only [exists_prop, and_assoc] using hB.nhds_hasBasis.nhds_closure.mem_iff.mp h | theorem | TopologicalSpace.IsTopologicalBasis.exists_closure_subset | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Set",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsInducing.regularSpace [TopologicalSpace Y] {f : Y → X}
(hf : IsInducing f) : RegularSpace Y | .of_hasBasis
(fun b => by rw [hf.nhds_eq_comap b]; exact (closed_nhds_basis _).comap _)
fun b s hs => by exact hs.2.preimage hf.continuous | theorem | Topology.IsInducing.regularSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace",
"TopologicalSpace",
"closed_nhds_basis",
"comap"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
regularSpace_induced (f : Y → X) : @RegularSpace Y (induced f ‹_›) | letI := induced f ‹_›
(IsInducing.induced f).regularSpace | theorem | regularSpace_induced | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
regularSpace_sInf {X} {T : Set (TopologicalSpace X)} (h : ∀ t ∈ T, @RegularSpace X t) :
@RegularSpace X (sInf T) | by
let _ := sInf T
have : ∀ a, (𝓝 a).HasBasis
(fun If : Σ I : Set T, I → Set X =>
If.1.Finite ∧ ∀ i : If.1, If.2 i ∈ @nhds X i a ∧ @IsClosed X i (If.2 i))
fun If => ⋂ i : If.1, If.snd i := fun a ↦ by
rw [nhds_sInf, ← iInf_subtype'']
exact .iInf fun t : T => @closed_nhds_basis X t (h t t... | theorem | regularSpace_sInf | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"RegularSpace",
"Set",
"TopologicalSpace",
"closed_nhds_basis",
"isClosed_iInter",
"nhds_sInf"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
regularSpace_iInf {ι X} {t : ι → TopologicalSpace X} (h : ∀ i, @RegularSpace X (t i)) :
@RegularSpace X (iInf t) | regularSpace_sInf <| forall_mem_range.mpr h | theorem | regularSpace_iInf | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace",
"TopologicalSpace",
"regularSpace_sInf"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
RegularSpace.inf {X} {t₁ t₂ : TopologicalSpace X} (h₁ : @RegularSpace X t₁)
(h₂ : @RegularSpace X t₂) : @RegularSpace X (t₁ ⊓ t₂) | by
rw [inf_eq_iInf]
exact regularSpace_iInf (Bool.forall_bool.2 ⟨h₂, h₁⟩) | theorem | RegularSpace.inf | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace",
"TopologicalSpace",
"regularSpace_iInf"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
SeparatedNhds.of_isCompact_isClosed {s t : Set X}
(hs : IsCompact s) (ht : IsClosed t) (hst : Disjoint s t) : SeparatedNhds s t | by
simpa only [separatedNhds_iff_disjoint, hs.disjoint_nhdsSet_left, disjoint_nhds_nhdsSet,
ht.closure_eq, disjoint_left] using hst | lemma | SeparatedNhds.of_isCompact_isClosed | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsClosed",
"IsCompact",
"SeparatedNhds",
"Set",
"disjoint_nhds_nhdsSet",
"separatedNhds_iff_disjoint"
] | In a regular space, if a compact set and a closed set are disjoint, then they have disjoint
neighborhoods. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
IsClosed.HasSeparatingCover {s t : Set X} [LindelofSpace X] [RegularSpace X]
(s_cl : IsClosed s) (t_cl : IsClosed t) (st_dis : Disjoint s t) : HasSeparatingCover s t | by
-- `IsLindelof.indexed_countable_subcover` requires the space be Nonempty
rcases isEmpty_or_nonempty X with empty_X | nonempty_X
· rw [subset_eq_empty (t := s) (fun ⦃_⦄ _ ↦ trivial) (univ_eq_empty_iff.mpr empty_X)]
exact hasSeparatingCovers_iff_separatedNhds.mpr (SeparatedNhds.empty_left t) |>.1
-- This ... | lemma | IsClosed.HasSeparatingCover | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"HasSeparatingCover",
"IsClosed",
"IsClosed.closure_subset_iff",
"IsOpen",
"LindelofSpace",
"RegularSpace",
"SeparatedNhds.empty_left",
"Set",
"closure",
"interior_subset",
"isEmpty_or_nonempty",
"isOpen_empty",
"isOpen_interior",
"regularSpace_TFAE"
] | This technique to witness `HasSeparatingCover` in regular Lindelöf topological spaces
will be used to prove regular Lindelöf spaces are normal. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
disjoint_nested_nhds_of_not_inseparable [RegularSpace X] {x y : X} (h : ¬Inseparable x y) :
∃ U₁ ∈ 𝓝 x, ∃ V₁ ∈ 𝓝 x, ∃ U₂ ∈ 𝓝 y, ∃ V₂ ∈ 𝓝 y,
IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂ | by
rcases r1_separation h with ⟨U₁, U₂, U₁_op, U₂_op, x_in, y_in, H⟩
rcases exists_mem_nhds_isClosed_subset (U₁_op.mem_nhds x_in) with ⟨V₁, V₁_in, V₁_closed, h₁⟩
rcases exists_mem_nhds_isClosed_subset (U₂_op.mem_nhds y_in) with ⟨V₂, V₂_in, V₂_closed, h₂⟩
exact ⟨U₁, mem_of_superset V₁_in h₁, V₁, V₁_in, U₂, mem_o... | theorem | disjoint_nested_nhds_of_not_inseparable | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"Inseparable",
"IsClosed",
"IsOpen",
"RegularSpace",
"exists_mem_nhds_isClosed_subset",
"r1_separation"
] | Given two separable points `x` and `y`, we can find neighbourhoods
`x ∈ V₁ ⊆ U₁` and `y ∈ V₂ ⊆ U₂`, with the `Vₖ` closed and the `Uₖ` open,
such that the `Uₖ` are disjoint. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
exists_compact_closed_between [LocallyCompactSpace X] [RegularSpace X]
{K U : Set X} (hK : IsCompact K) (hU : IsOpen U) (h_KU : K ⊆ U) :
∃ L, IsCompact L ∧ IsClosed L ∧ K ⊆ interior L ∧ L ⊆ U | let ⟨L, L_comp, KL, LU⟩ := exists_compact_between hK hU h_KU
⟨closure L, L_comp.closure, isClosed_closure, KL.trans <| interior_mono subset_closure,
L_comp.closure_subset_of_isOpen hU LU⟩ | theorem | exists_compact_closed_between | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"IsCompact",
"IsOpen",
"LocallyCompactSpace",
"RegularSpace",
"Set",
"exists_compact_between",
"interior",
"interior_mono",
"isClosed_closure",
"subset_closure"
] | In a (possibly non-Hausdorff) locally compact regular space, for every containment `K ⊆ U` of
a compact set `K` in an open set `U`, there is a compact closed neighborhood `L`
such that `K ⊆ L ⊆ U`: equivalently, there is a compact closed set `L` such
that `K ⊆ interior L` and `L ⊆ U`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
IsCompact.nhdsSet_basis_isCompact_isClosed
[LocallyCompactSpace X] [RegularSpace X] {K : Set X} (hK : IsCompact K) :
(𝓝ˢ K).HasBasis (fun L ↦ L ∈ 𝓝ˢ K ∧ IsCompact L ∧ IsClosed L) id | by
rw [hasBasis_self, (hasBasis_nhdsSet _).forall_iff (by grind)]
intro U ⟨hU, h_KU⟩
obtain ⟨L, hL, hL', hKL, hLU⟩ := exists_compact_closed_between hK hU h_KU
exact ⟨L, by rwa [← subset_interior_iff_mem_nhdsSet], ⟨hL, hL'⟩, hLU⟩ | theorem | IsCompact.nhdsSet_basis_isCompact_isClosed | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"IsCompact",
"LocallyCompactSpace",
"RegularSpace",
"Set",
"exists_compact_closed_between",
"hasBasis_nhdsSet",
"subset_interior_iff_mem_nhdsSet"
] | In a (possibly non-Hausdorff) locally compact regular space, for every compact set `K`,
`𝓝ˢ K` has a basis consisting of closed compact sets. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
exists_open_between_and_isCompact_closure [LocallyCompactSpace X] [RegularSpace X]
{K U : Set X} (hK : IsCompact K) (hU : IsOpen U) (hKU : K ⊆ U) :
∃ V, IsOpen V ∧ K ⊆ V ∧ closure V ⊆ U ∧ IsCompact (closure V) | by
rcases exists_compact_closed_between hK hU hKU with ⟨L, L_compact, L_closed, KL, LU⟩
have A : closure (interior L) ⊆ L := by
apply (closure_mono interior_subset).trans (le_of_eq L_closed.closure_eq)
refine ⟨interior L, isOpen_interior, KL, A.trans LU, ?_⟩
exact L_compact.closure_of_subset interior_subset | theorem | exists_open_between_and_isCompact_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsCompact",
"IsOpen",
"LocallyCompactSpace",
"RegularSpace",
"Set",
"closure",
"closure_mono",
"exists_compact_closed_between",
"interior",
"interior_subset",
"isOpen_interior",
"le_of_eq",
"trans"
] | In a locally compact regular space, given a compact set `K` inside an open set `U`, we can find
an open set `V` between these sets with compact closure: `K ⊆ V` and the closure of `V` is
inside `U`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
IsCompact.closure_eq_nhdsKer [RegularSpace X] {s : Set X} (hs : IsCompact s) :
closure s = nhdsKer s | by
apply subset_antisymm
· rw [nhdsKer, ← hs.lift'_closure_nhdsSet]
simp +contextual [Filter.lift', Filter.lift, closure_mono, subset_of_mem_nhdsSet]
· intro y hy
by_contra! hy'
rw [← _root_.disjoint_nhdsSet_nhds, Filter.disjoint_iff] at hy'
obtain ⟨t, hts, t', ht'y, H⟩ := hy'
exact Set.disjoi... | lemma | IsCompact.closure_eq_nhdsKer | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Filter.disjoint_iff",
"Filter.lift",
"Filter.lift'",
"IsCompact",
"RegularSpace",
"Set",
"closure",
"closure_mono",
"mem_of_mem_nhds",
"nhdsKer",
"subset_antisymm",
"subset_of_mem_nhdsSet"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
T25Space (X : Type u) [TopologicalSpace X] : Prop where
/-- Given two distinct points in a T₂.₅ space, their filters of closed neighborhoods are
disjoint. -/
t2_5 : ∀ ⦃x y : X⦄, x ≠ y → Disjoint ((𝓝 x).lift' closure) ((𝓝 y).lift' closure) | class | T25Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"TopologicalSpace",
"closure"
] | A T₂.₅ space, also known as a Urysohn space, is a topological space
where for every pair `x ≠ y`, there are two open sets, with the intersection of closures
empty, one containing `x` and the other `y` . | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
disjoint_lift'_closure_nhds [T25Space X] {x y : X} :
Disjoint ((𝓝 x).lift' closure) ((𝓝 y).lift' closure) ↔ x ≠ y | ⟨fun h hxy => by simp [hxy, nhds_neBot.ne] at h, fun h => T25Space.t2_5 h⟩ | theorem | disjoint_lift'_closure_nhds | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"T25Space",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
exists_nhds_disjoint_closure [T25Space X] {x y : X} (h : x ≠ y) :
∃ s ∈ 𝓝 x, ∃ t ∈ 𝓝 y, Disjoint (closure s) (closure t) | ((𝓝 x).basis_sets.lift'_closure.disjoint_iff (𝓝 y).basis_sets.lift'_closure).1 <|
disjoint_lift'_closure_nhds.2 h | theorem | exists_nhds_disjoint_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"T25Space",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
exists_open_nhds_disjoint_closure [T25Space X] {x y : X} (h : x ≠ y) :
∃ u : Set X,
x ∈ u ∧ IsOpen u ∧ ∃ v : Set X, y ∈ v ∧ IsOpen v ∧ Disjoint (closure u) (closure v) | by
simpa only [exists_prop, and_assoc] using
((nhds_basis_opens x).lift'_closure.disjoint_iff (nhds_basis_opens y).lift'_closure).1
(disjoint_lift'_closure_nhds.2 h) | theorem | exists_open_nhds_disjoint_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsOpen",
"Set",
"T25Space",
"closure",
"nhds_basis_opens"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
T25Space.of_injective_continuous [TopologicalSpace Y] [T25Space Y] {f : X → Y}
(hinj : Injective f) (hcont : Continuous f) : T25Space X | where
t2_5 x y hne := (tendsto_lift'_closure_nhds hcont x).disjoint (t2_5 <| hinj.ne hne)
(tendsto_lift'_closure_nhds hcont y) | theorem | T25Space.of_injective_continuous | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Continuous",
"T25Space",
"TopologicalSpace",
"tendsto_lift'_closure_nhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsEmbedding.t25Space [TopologicalSpace Y] [T25Space Y] {f : X → Y}
(hf : IsEmbedding f) : T25Space X | .of_injective_continuous hf.injective hf.continuous | theorem | Topology.IsEmbedding.t25Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T25Space",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Homeomorph.t25Space [TopologicalSpace Y] [T25Space X] (h : X ≃ₜ Y) : T25Space Y | h.symm.isEmbedding.t25Space | theorem | Homeomorph.t25Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T25Space",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Subtype.instT25Space [T25Space X] {p : X → Prop} : T25Space {x // p x} | IsEmbedding.subtypeVal.t25Space | instance | Subtype.instT25Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T25Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
T3Space (X : Type u) [TopologicalSpace X] : Prop extends T0Space X, RegularSpace X | class | T3Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace",
"T0Space",
"TopologicalSpace"
] | A T₃ space is a T₀ space which is a regular space. Any T₃ space is a T₁ space, a T₂ space, and
a T₂.₅ space. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
RegularSpace.t3Space_iff_t0Space [RegularSpace X] : T3Space X ↔ T0Space X | by
constructor <;> intro <;> infer_instance | theorem | RegularSpace.t3Space_iff_t0Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"RegularSpace",
"T0Space",
"T3Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsEmbedding.t3Space [TopologicalSpace Y] [T3Space Y] {f : X → Y}
(hf : IsEmbedding f) : T3Space X | { toT0Space := hf.t0Space
toRegularSpace := hf.isInducing.regularSpace } | theorem | Topology.IsEmbedding.t3Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T3Space",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Homeomorph.t3Space [TopologicalSpace Y] [T3Space X] (h : X ≃ₜ Y) : T3Space Y | h.symm.isEmbedding.t3Space | theorem | Homeomorph.t3Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T3Space",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Subtype.t3Space [T3Space X] {p : X → Prop} : T3Space (Subtype p) | IsEmbedding.subtypeVal.t3Space | instance | Subtype.t3Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T3Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
ULift.instT3Space [T3Space X] : T3Space (ULift X) | IsEmbedding.uliftDown.t3Space | instance | ULift.instT3Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T3Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
disjoint_nested_nhds [T3Space X] {x y : X} (h : x ≠ y) :
∃ U₁ ∈ 𝓝 x, ∃ V₁ ∈ 𝓝 x, ∃ U₂ ∈ 𝓝 y, ∃ V₂ ∈ 𝓝 y,
IsClosed V₁ ∧ IsClosed V₂ ∧ IsOpen U₁ ∧ IsOpen U₂ ∧ V₁ ⊆ U₁ ∧ V₂ ⊆ U₂ ∧ Disjoint U₁ U₂ | disjoint_nested_nhds_of_not_inseparable (mt Inseparable.eq h) | theorem | disjoint_nested_nhds | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"Inseparable.eq",
"IsClosed",
"IsOpen",
"T3Space",
"disjoint_nested_nhds_of_not_inseparable"
] | Given two points `x ≠ y`, we can find neighbourhoods `x ∈ V₁ ⊆ U₁` and `y ∈ V₂ ⊆ U₂`,
with the `Vₖ` closed and the `Uₖ` open, such that the `Uₖ` are disjoint. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
NormalSpace (X : Type u) [TopologicalSpace X] : Prop where
/-- Two disjoint sets in a normal space admit disjoint neighbourhoods. -/
normal : ∀ s t : Set X, IsClosed s → IsClosed t → Disjoint s t → SeparatedNhds s t | class | NormalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsClosed",
"SeparatedNhds",
"Set",
"TopologicalSpace"
] | A topological space is said to be a *normal space* if any two disjoint closed sets
have disjoint open neighborhoods. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
normal_separation [NormalSpace X] {s t : Set X} (H1 : IsClosed s) (H2 : IsClosed t)
(H3 : Disjoint s t) : SeparatedNhds s t | NormalSpace.normal s t H1 H2 H3 | theorem | normal_separation | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsClosed",
"NormalSpace",
"SeparatedNhds",
"Set"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
disjoint_nhdsSet_nhdsSet [NormalSpace X] {s t : Set X} (hs : IsClosed s) (ht : IsClosed t)
(hd : Disjoint s t) : Disjoint (𝓝ˢ s) (𝓝ˢ t) | (normal_separation hs ht hd).disjoint_nhdsSet | theorem | disjoint_nhdsSet_nhdsSet | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsClosed",
"NormalSpace",
"Set",
"normal_separation"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
normal_exists_closure_subset [NormalSpace X] {s t : Set X} (hs : IsClosed s) (ht : IsOpen t)
(hst : s ⊆ t) : ∃ u, IsOpen u ∧ s ⊆ u ∧ closure u ⊆ t | by
have : Disjoint s tᶜ := Set.disjoint_left.mpr fun x hxs hxt => hxt (hst hxs)
rcases normal_separation hs (isClosed_compl_iff.2 ht) this with
⟨s', t', hs', ht', hss', htt', hs't'⟩
refine ⟨s', hs', hss', Subset.trans (closure_minimal ?_ (isClosed_compl_iff.2 ht'))
(compl_subset_comm.1 htt')⟩
exact fun ... | theorem | normal_exists_closure_subset | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"IsClosed",
"IsOpen",
"NormalSpace",
"Set",
"closure",
"closure_minimal",
"normal_separation"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
exists_mem_nhdsSet_isClosed_subset [NormalSpace X] {u s : Set X} (h : s ∈ 𝓝ˢ u)
(hu : IsClosed u) : ∃ t ∈ 𝓝ˢ u, IsClosed t ∧ t ⊆ s | by
obtain ⟨o, ho_open, huo, hos⟩ := mem_nhdsSet_iff_exists.mp h
obtain ⟨v, hv_open, huv, hcvo⟩ := normal_exists_closure_subset hu ho_open huo
refine ⟨closure v, ?_, isClosed_closure, hcvo.trans hos⟩
exact mem_of_superset (mem_nhdsSet_iff_exists.mpr ⟨v, hv_open, huv, subset_rfl⟩) subset_closure | theorem | exists_mem_nhdsSet_isClosed_subset | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"NormalSpace",
"Set",
"isClosed_closure",
"normal_exists_closure_subset",
"subset_closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
closed_nhdsSet_basis [NormalSpace X] (u : Set X) (hu : IsClosed u) : (𝓝ˢ u).HasBasis
(fun s : Set X ↦ s ∈ 𝓝ˢ u ∧ IsClosed s) id | by
refine hasBasis_self.2 fun _ ht ↦ exists_mem_nhdsSet_isClosed_subset ht hu | theorem | closed_nhdsSet_basis | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"NormalSpace",
"Set",
"exists_mem_nhdsSet_isClosed_subset"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
lift'_nhdsSet_closure [NormalSpace X] (u : Set X) (hu : IsClosed u) :
(𝓝ˢ u).lift' closure = 𝓝ˢ u | (closed_nhdsSet_basis u hu).lift'_closure_eq_self fun _ ↦ And.right | theorem | lift'_nhdsSet_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"NormalSpace",
"Set",
"closed_nhdsSet_basis",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Filter.HasBasis.nhdsSet_closure [NormalSpace X] {ι : Sort*} {u : Set X} {p : ι → Prop}
{s : ι → Set X} (hu : IsClosed u) (h : (𝓝ˢ u).HasBasis p s) :
(𝓝ˢ u).HasBasis p fun i ↦ closure (s i) | lift'_nhdsSet_closure u hu ▸ h.lift'_closure | theorem | Filter.HasBasis.nhdsSet_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"NormalSpace",
"Set",
"closure",
"lift'_nhdsSet_closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
hasBasis_nhdsSet_closure [NormalSpace X] (u : Set X) (hu : IsClosed u) :
(𝓝ˢ u).HasBasis (fun s => s ∈ 𝓝ˢ u) closure | (𝓝ˢ u).basis_sets.nhdsSet_closure hu | theorem | hasBasis_nhdsSet_closure | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsClosed",
"NormalSpace",
"Set",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsClosedEmbedding.normalSpace [TopologicalSpace Y] [NormalSpace Y]
{f : X → Y} (hf : IsClosedEmbedding f) : NormalSpace X | where
normal s t hs ht hst := by
have H : SeparatedNhds (f '' s) (f '' t) :=
NormalSpace.normal (f '' s) (f '' t) (hf.isClosedMap s hs) (hf.isClosedMap t ht)
(disjoint_image_of_injective hf.injective hst)
exact (H.preimage hf.continuous).mono (subset_preimage_image _ _) (subset_preimage_image _ ... | theorem | Topology.IsClosedEmbedding.normalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"NormalSpace",
"SeparatedNhds",
"TopologicalSpace"
] | If the codomain of a closed embedding is a normal space, then so is the domain. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Homeomorph.normalSpace [TopologicalSpace Y] [NormalSpace X] (h : X ≃ₜ Y) :
NormalSpace Y | h.symm.isClosedEmbedding.normalSpace | theorem | Homeomorph.normalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"NormalSpace",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
T4Space (X : Type u) [TopologicalSpace X] : Prop extends T1Space X, NormalSpace X | class | T4Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"NormalSpace",
"T1Space",
"TopologicalSpace"
] | A T₄ space is a normal T₁ space. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsClosedEmbedding.t4Space [TopologicalSpace Y] [T4Space Y] {f : X → Y}
(hf : IsClosedEmbedding f) : T4Space X | where
toT1Space := hf.isEmbedding.t1Space
toNormalSpace := hf.normalSpace | theorem | Topology.IsClosedEmbedding.t4Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T4Space",
"TopologicalSpace"
] | If the codomain of a closed embedding is a T₄ space, then so is the domain. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Homeomorph.t4Space [TopologicalSpace Y] [T4Space X] (h : X ≃ₜ Y) : T4Space Y | h.symm.isClosedEmbedding.t4Space | theorem | Homeomorph.t4Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T4Space",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
ULift.instT4Space [T4Space X] : T4Space (ULift X) | IsClosedEmbedding.uliftDown.t4Space | instance | ULift.instT4Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T4Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
CompletelyNormalSpace (X : Type u) [TopologicalSpace X] : Prop where
/-- If `closure s` is disjoint with `t`, and `s` is disjoint with `closure t`, then `s` and `t`
admit disjoint neighbourhoods. -/
completely_normal :
∀ ⦃s t : Set X⦄, Disjoint (closure s) t → Disjoint s (closure t) → Disjoint (𝓝ˢ s) (𝓝ˢ t) | class | CompletelyNormalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Disjoint",
"Set",
"TopologicalSpace",
"closure"
] | A topological space `X` is a *completely normal space* provided that for any two sets `s`, `t`
such that if both `closure s` is disjoint with `t`, and `s` is disjoint with `closure t`,
then there exist disjoint neighbourhoods of `s` and `t`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsInducing.completelyNormalSpace [TopologicalSpace Y] [CompletelyNormalSpace Y]
{e : X → Y} (he : IsInducing e) : CompletelyNormalSpace X | by
refine ⟨fun s t hd₁ hd₂ => ?_⟩
simp only [he.nhdsSet_eq_comap]
refine disjoint_comap (completely_normal ?_ ?_)
· rwa [← subset_compl_iff_disjoint_left, image_subset_iff, preimage_compl,
← he.closure_eq_preimage_closure_image, subset_compl_iff_disjoint_left]
· rwa [← subset_compl_iff_disjoint_right, i... | theorem | Topology.IsInducing.completelyNormalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"CompletelyNormalSpace",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
ULift.instCompletelyNormalSpace [CompletelyNormalSpace X] :
CompletelyNormalSpace (ULift X) | IsEmbedding.uliftDown.completelyNormalSpace | instance | ULift.instCompletelyNormalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"CompletelyNormalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
completelyNormalSpace_iff_forall_isOpen_normalSpace :
CompletelyNormalSpace X ↔ ∀ s : Set X, IsOpen s → NormalSpace s | by
refine ⟨fun _ _ _ => inferInstance, fun h => ⟨fun s t hSt hsT => ?_⟩⟩
let e := (closure s ∩ closure t)ᶜ
have he : IsOpen e := (isClosed_closure.inter isClosed_closure).isOpen_compl
specialize h e he
have hst : Disjoint (((↑) : e → X) ⁻¹' closure s) (((↑) : e → X) ⁻¹' closure t) := by
rw [disjoint_left]... | theorem | completelyNormalSpace_iff_forall_isOpen_normalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"CompletelyNormalSpace",
"Disjoint",
"IsOpen",
"NormalSpace",
"Set",
"Subtype.preimage_val_subset_preimage_val_iff",
"closure",
"continuous_subtype_val",
"isClosed_closure",
"normal_separation",
"separatedNhds_iff_disjoint"
] | A space is completely normal iff all open subspaces are normal. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
completelyNormalSpace_iff_forall_normalSpace :
CompletelyNormalSpace X ↔ ∀ s : Set X, NormalSpace s | ⟨fun _ _ => inferInstance, fun h =>
completelyNormalSpace_iff_forall_isOpen_normalSpace.2 fun s _ => h s⟩
alias ⟨_, CompletelyNormalSpace.of_forall_isOpen_normalSpace⟩ :=
completelyNormalSpace_iff_forall_isOpen_normalSpace
alias ⟨_, CompletelyNormalSpace.of_forall_normalSpace⟩ :=
completelyNormalSpace_iff_fora... | theorem | completelyNormalSpace_iff_forall_normalSpace | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"CompletelyNormalSpace",
"NormalSpace",
"Set",
"completelyNormalSpace_iff_forall_isOpen_normalSpace"
] | A space is completely normal iff it is hereditarily normal. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
T5Space (X : Type u) [TopologicalSpace X] : Prop extends T1Space X, CompletelyNormalSpace X | class | T5Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"CompletelyNormalSpace",
"T1Space",
"TopologicalSpace"
] | A T₅ space is a completely normal T₁ space. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Topology.IsEmbedding.t5Space [TopologicalSpace Y] [T5Space Y] {e : X → Y}
(he : IsEmbedding e) : T5Space X | where
toCompletelyNormalSpace := he.completelyNormalSpace
toT1Space := he.t1Space | theorem | Topology.IsEmbedding.t5Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T5Space",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Homeomorph.t5Space [TopologicalSpace Y] [T5Space X] (h : X ≃ₜ Y) : T5Space Y | h.symm.isClosedEmbedding.t5Space | theorem | Homeomorph.t5Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T5Space",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
ULift.instT5Space [T5Space X] : T5Space (ULift X) | IsEmbedding.uliftDown.t5Space | instance | ULift.instT5Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"T5Space"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
t5Space_iff_forall_isOpen_t4Space :
T5Space X ↔ ∀ s : Set X, IsOpen s → T4Space s | where
mp _ _ _ := inferInstance
mpr h :=
{ toCompletelyNormalSpace :=
completelyNormalSpace_iff_forall_isOpen_normalSpace.2 fun s hs => (h s hs).toNormalSpace
toT1Space :=
have := h univ isOpen_univ
t1Space_of_injective_of_continuous
(fun _ _ => congrArg Subtype.val) (con... | theorem | t5Space_iff_forall_isOpen_t4Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"IsOpen",
"Set",
"T4Space",
"T5Space",
"isOpen_univ",
"t1Space_of_injective_of_continuous"
] | A space is a `T5Space` iff all its open subspaces are `T4Space`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
t5Space_iff_forall_t4Space :
T5Space X ↔ ∀ s : Set X, T4Space s | ⟨fun _ _ => inferInstance, fun h => t5Space_iff_forall_isOpen_t4Space.2 fun s _ => h s⟩
alias ⟨_, T5Space.of_forall_isOpen_t4Space⟩ := t5Space_iff_forall_isOpen_t4Space
alias ⟨_, T5Space.of_forall_t4Space⟩ := t5Space_iff_forall_t4Space | theorem | t5Space_iff_forall_t4Space | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"Set",
"T4Space",
"T5Space",
"t5Space_iff_forall_isOpen_t4Space"
] | A space is `T5Space` iff it is hereditarily `T4Space`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
connectedComponent_eq_iInter_isClopen [T2Space X] [CompactSpace X] (x : X) :
connectedComponent x = ⋂ s : { s : Set X // IsClopen s ∧ x ∈ s }, s | by
apply Subset.antisymm connectedComponent_subset_iInter_isClopen
-- Reduce to showing that the clopen intersection is connected.
refine IsPreconnected.subset_connectedComponent ?_ (mem_iInter.2 fun s => s.2.2)
-- We do this by showing that any disjoint cover by two closed sets implies
-- that one of these c... | theorem | connectedComponent_eq_iInter_isClopen | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"CompactSpace",
"Disjoint.left_le_of_le_sup_right",
"IsClopen",
"IsClosed",
"IsPreconnected.subset_connectedComponent",
"Set",
"T2Space",
"by_cases",
"connectedComponent",
"connectedComponent_subset_iInter_isClopen",
"isClopen_biInter_finset",
"isClopen_inter_of_disjoint_cover_clopen",
"isCl... | In a compact T₂ space, the connected component of a point equals the intersection of all
its clopen neighbourhoods. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
ConnectedComponents.t2 [T2Space X] [CompactSpace X] : T2Space (ConnectedComponents X) | by
-- Fix 2 distinct connected components, with points a and b
refine ⟨ConnectedComponents.surjective_coe.forall₂.2 fun a b ne => ?_⟩
rw [ConnectedComponents.coe_ne_coe] at ne
have h := connectedComponent_disjoint ne
-- write ↑b as the intersection of all clopen subsets containing it
rw [connectedComponent_... | instance | ConnectedComponents.t2 | Topology.Separation | Mathlib/Topology/Separation/Regular.lean | [] | [
"CompactSpace",
"ConnectedComponents",
"ConnectedComponents.coe_ne_coe",
"IsClopen",
"Set",
"T2Space",
"connectedComponent",
"connectedComponent_disjoint",
"connectedComponent_eq_iInter_isClopen",
"connectedComponents_preimage_image",
"isClopen_biInter_finset",
"isClosed_connectedComponent",
... | `ConnectedComponents X` is Hausdorff when `X` is Hausdorff and compact | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
SeparatedNhds : Set X → Set X → Prop | fun s t : Set X =>
∃ U V : Set X, IsOpen U ∧ IsOpen V ∧ s ⊆ U ∧ t ⊆ V ∧ Disjoint U V | def | SeparatedNhds | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint",
"IsOpen",
"Set"
] | `SeparatedNhds` is a predicate on pairs of sub`Set`s of a topological space. It holds if the two
sub`Set`s are contained in disjoint open sets. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
separatedNhds_iff_disjoint {s t : Set X} : SeparatedNhds s t ↔ Disjoint (𝓝ˢ s) (𝓝ˢ t) | by
simp only [(hasBasis_nhdsSet s).disjoint_iff (hasBasis_nhdsSet t), SeparatedNhds, ←
exists_and_left, and_assoc, and_comm, and_left_comm]
alias ⟨SeparatedNhds.disjoint_nhdsSet, _⟩ := separatedNhds_iff_disjoint | theorem | separatedNhds_iff_disjoint | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint",
"SeparatedNhds",
"Set",
"disjoint_iff",
"hasBasis_nhdsSet"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
HasSeparatingCover : Set X → Set X → Prop | fun s t ↦
∃ u : ℕ → Set X, s ⊆ ⋃ n, u n ∧ ∀ n, IsOpen (u n) ∧ Disjoint (closure (u n)) t | def | HasSeparatingCover | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint",
"IsOpen",
"Set",
"closure"
] | `HasSeparatingCover`s can be useful witnesses for `SeparatedNhds`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasSeparatingCovers_iff_separatedNhds {s t : Set X} :
HasSeparatingCover s t ∧ HasSeparatingCover t s ↔ SeparatedNhds s t | by
constructor
· rintro ⟨⟨u, u_cov, u_props⟩, ⟨v, v_cov, v_props⟩⟩
have open_lemma : ∀ (u₀ a : ℕ → Set X), (∀ n, IsOpen (u₀ n)) →
IsOpen (⋃ n, u₀ n \ closure (a n)) := fun _ _ u₀i_open ↦
isOpen_iUnion fun i ↦ (u₀i_open i).sdiff isClosed_closure
have cover_lemma : ∀ (h₀ : Set X) (u₀ v₀ : ℕ → Se... | theorem | hasSeparatingCovers_iff_separatedNhds | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint",
"HasSeparatingCover",
"IsOpen",
"SeparatedNhds",
"Set",
"Set.disjoint_left",
"closure",
"closure_iUnion₂_le_nat",
"isClosed_closure",
"isOpen_iUnion",
"le_of_lt",
"subset_closure"
] | Used to prove that a regular topological space with Lindelöf topology is a normal space,
and a perfectly normal space is a completely normal space. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Set.hasSeparatingCover_empty_left (s : Set X) : HasSeparatingCover ∅ s | ⟨fun _ ↦ ∅, empty_subset (⋃ _, ∅),
fun _ ↦ ⟨isOpen_empty, by simp only [closure_empty, empty_disjoint]⟩⟩ | theorem | Set.hasSeparatingCover_empty_left | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"HasSeparatingCover",
"Set",
"closure_empty"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
Set.hasSeparatingCover_empty_right (s : Set X) : HasSeparatingCover s ∅ | ⟨fun _ ↦ univ, (subset_univ s).trans univ.iUnion_const.symm.subset,
fun _ ↦ ⟨isOpen_univ, by apply disjoint_empty⟩⟩ | theorem | Set.hasSeparatingCover_empty_right | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"HasSeparatingCover",
"Set",
"trans"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
HasSeparatingCover.mono {s₁ s₂ t₁ t₂ : Set X} (sc_st : HasSeparatingCover s₂ t₂)
(s_sub : s₁ ⊆ s₂) (t_sub : t₁ ⊆ t₂) : HasSeparatingCover s₁ t₁ | by
obtain ⟨u, u_cov, u_props⟩ := sc_st
exact
⟨u,
s_sub.trans u_cov,
fun n ↦
⟨(u_props n).1,
disjoint_of_subset (fun ⦃_⦄ a ↦ a) t_sub (u_props n).2⟩⟩ | theorem | HasSeparatingCover.mono | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"HasSeparatingCover",
"Set"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
symm : SeparatedNhds s t → SeparatedNhds t s | fun ⟨U, V, oU, oV, aU, bV, UV⟩ =>
⟨V, U, oV, oU, bV, aU, Disjoint.symm UV⟩ | theorem | SeparatedNhds.symm | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint.symm",
"SeparatedNhds",
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
comm (s t : Set X) : SeparatedNhds s t ↔ SeparatedNhds t s | ⟨symm, symm⟩ | theorem | SeparatedNhds.comm | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"SeparatedNhds",
"Set",
"comm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
preimage [TopologicalSpace Y] {f : X → Y} {s t : Set Y} (h : SeparatedNhds s t)
(hf : Continuous f) : SeparatedNhds (f ⁻¹' s) (f ⁻¹' t) | let ⟨U, V, oU, oV, sU, tV, UV⟩ := h
⟨f ⁻¹' U, f ⁻¹' V, oU.preimage hf, oV.preimage hf, preimage_mono sU, preimage_mono tV,
UV.preimage f⟩ | theorem | SeparatedNhds.preimage | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Continuous",
"SeparatedNhds",
"Set",
"TopologicalSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
disjoint (h : SeparatedNhds s t) : Disjoint s t | let ⟨_, _, _, _, hsU, htV, hd⟩ := h; hd.mono hsU htV | theorem | SeparatedNhds.disjoint | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint",
"SeparatedNhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
disjoint_closure_left (h : SeparatedNhds s t) : Disjoint (closure s) t | let ⟨_U, _V, _, hV, hsU, htV, hd⟩ := h
(hd.closure_left hV).mono (closure_mono hsU) htV | theorem | SeparatedNhds.disjoint_closure_left | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint",
"SeparatedNhds",
"closure",
"closure_mono"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
disjoint_closure_right (h : SeparatedNhds s t) : Disjoint s (closure t) | h.symm.disjoint_closure_left.symm | theorem | SeparatedNhds.disjoint_closure_right | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"Disjoint",
"SeparatedNhds",
"closure"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
empty_right (s : Set X) : SeparatedNhds s ∅ | ⟨_, _, isOpen_univ, isOpen_empty, fun a _ => mem_univ a, Subset.rfl, disjoint_empty _⟩ | theorem | SeparatedNhds.empty_right | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"SeparatedNhds",
"Set",
"isOpen_empty",
"isOpen_univ"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
empty_left (s : Set X) : SeparatedNhds ∅ s | (empty_right _).symm | theorem | SeparatedNhds.empty_left | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"SeparatedNhds",
"Set",
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
mono (h : SeparatedNhds s₂ t₂) (hs : s₁ ⊆ s₂) (ht : t₁ ⊆ t₂) : SeparatedNhds s₁ t₁ | let ⟨U, V, hU, hV, hsU, htV, hd⟩ := h
⟨U, V, hU, hV, hs.trans hsU, ht.trans htV, hd⟩ | theorem | SeparatedNhds.mono | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"SeparatedNhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
union_left : SeparatedNhds s u → SeparatedNhds t u → SeparatedNhds (s ∪ t) u | by
simpa only [separatedNhds_iff_disjoint, nhdsSet_union, disjoint_sup_left] using And.intro | theorem | SeparatedNhds.union_left | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"SeparatedNhds",
"disjoint_sup_left",
"nhdsSet_union",
"separatedNhds_iff_disjoint"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
union_right (ht : SeparatedNhds s t) (hu : SeparatedNhds s u) : SeparatedNhds s (t ∪ u) | (ht.symm.union_left hu.symm).symm | theorem | SeparatedNhds.union_right | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"SeparatedNhds",
"symm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isOpen_left_of_isOpen_union (hst : SeparatedNhds s t) (hst' : IsOpen (s ∪ t)) : IsOpen s | by
obtain ⟨u, v, hu, hv, hsu, htv, huv⟩ := hst
suffices s = (s ∪ t) ∩ u from this ▸ hst'.inter hu
rw [union_inter_distrib_right, (huv.symm.mono_left htv).inter_eq, union_empty,
inter_eq_left.2 hsu] | lemma | SeparatedNhds.isOpen_left_of_isOpen_union | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"IsOpen",
"SeparatedNhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isOpen_right_of_isOpen_union (hst : SeparatedNhds s t) (hst' : IsOpen (s ∪ t)) : IsOpen t | hst.symm.isOpen_left_of_isOpen_union (union_comm _ _ ▸ hst') | lemma | SeparatedNhds.isOpen_right_of_isOpen_union | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"IsOpen",
"SeparatedNhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isOpen_union_iff (hst : SeparatedNhds s t) : IsOpen (s ∪ t) ↔ IsOpen s ∧ IsOpen t | ⟨fun h ↦ ⟨hst.isOpen_left_of_isOpen_union h, hst.isOpen_right_of_isOpen_union h⟩,
fun ⟨h1, h2⟩ ↦ h1.union h2⟩ | lemma | SeparatedNhds.isOpen_union_iff | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"IsOpen",
"SeparatedNhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isClosed_left_of_isClosed_union (hst : SeparatedNhds s t) (hst' : IsClosed (s ∪ t)) :
IsClosed s | by
obtain ⟨u, v, hu, hv, hsu, htv, huv⟩ := hst
rw [← isOpen_compl_iff] at hst' ⊢
suffices sᶜ = (s ∪ t)ᶜ ∪ v from this ▸ hst'.union hv
rw [← compl_inj_iff, Set.compl_union, compl_compl, compl_compl, union_inter_distrib_right,
(disjoint_compl_right.mono_left htv).inter_eq, union_empty, left_eq_inter, subset_c... | lemma | SeparatedNhds.isClosed_left_of_isClosed_union | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"IsClosed",
"SeparatedNhds",
"Set.compl_union",
"compl_compl",
"compl_inj_iff",
"isOpen_compl_iff"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isClosed_right_of_isClosed_union (hst : SeparatedNhds s t) (hst' : IsClosed (s ∪ t)) :
IsClosed t | hst.symm.isClosed_left_of_isClosed_union (union_comm _ _ ▸ hst') | lemma | SeparatedNhds.isClosed_right_of_isClosed_union | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"IsClosed",
"SeparatedNhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isClosed_union_iff (hst : SeparatedNhds s t) : IsClosed (s ∪ t) ↔ IsClosed s ∧ IsClosed t | ⟨fun h ↦ ⟨hst.isClosed_left_of_isClosed_union h, hst.isClosed_right_of_isClosed_union h⟩,
fun ⟨h1, h2⟩ ↦ h1.union h2⟩ | lemma | SeparatedNhds.isClosed_union_iff | Topology.Separation | Mathlib/Topology/Separation/SeparatedNhds.lean | [] | [
"IsClosed",
"SeparatedNhds"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.