fact stringlengths 6 3.84k | type stringclasses 11 values | library stringclasses 32 values | imports listlengths 1 14 | filename stringlengths 20 95 | symbolic_name stringlengths 1 90 | docstring stringlengths 7 20k ⌀ |
|---|---|---|---|---|---|---|
TopologicalSpace.deltaGenerated (X : Type*) [TopologicalSpace X] : TopologicalSpace X :=
⨆ f : (n : ℕ) × C(((Fin n) → ℝ), X), coinduced f.2 inferInstance | def | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | TopologicalSpace.deltaGenerated | The topology coinduced by all maps from ℝⁿ into a space. |
deltaGenerated_eq_coinduced : deltaGenerated X = coinduced
(fun x : (f : (n : ℕ) × C(Fin n → ℝ, X)) × (Fin f.1 → ℝ) ↦ x.1.2 x.2) inferInstance := by
rw [deltaGenerated, instTopologicalSpaceSigma, coinduced_iSup]; rfl | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | deltaGenerated_eq_coinduced | The delta-generated topology is also coinduced by a single map out of a sigma type. |
deltaGenerated_le : deltaGenerated X ≤ tX :=
iSup_le_iff.mpr fun f ↦ f.2.continuous.coinduced_le | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | deltaGenerated_le | The delta-generated topology is at least as fine as the original one. |
isOpen_deltaGenerated_iff {u : Set X} :
IsOpen[deltaGenerated X] u ↔ ∀ n (p : C(Fin n → ℝ, X)), IsOpen (p ⁻¹' u) := by
simp_rw [deltaGenerated, isOpen_iSup_iff, isOpen_coinduced, Sigma.forall] | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | isOpen_deltaGenerated_iff | A set is open in `deltaGenerated X` iff all its preimages under continuous functions ℝⁿ → X are
open. |
private continuous_euclidean_to_deltaGenerated {n : ℕ} {f : (Fin n → ℝ) → X} :
Continuous[_, deltaGenerated X] f ↔ Continuous f := by
simp_rw [continuous_iff_coinduced_le]
refine ⟨fun h ↦ h.trans deltaGenerated_le, fun h ↦ ?_⟩
simp_rw [deltaGenerated]
exact le_iSup_of_le (i := ⟨n, f, continuous_iff_coinduced_le.mpr h⟩) le_rfl | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | continuous_euclidean_to_deltaGenerated | A map from ℝⁿ to X is continuous iff it is continuous regarding the
delta-generated topology on X. Outside of this file, use the more general
`continuous_to_deltaGenerated` instead. |
deltaGenerated_deltaGenerated_eq :
@deltaGenerated X (deltaGenerated X) = deltaGenerated X := by
ext u; simp_rw [isOpen_deltaGenerated_iff]; refine forall_congr' fun n ↦ ?_
refine ⟨fun h p ↦ h <| @ContinuousMap.mk _ _ _ (_) p ?_, fun h p ↦ h ⟨p, ?_⟩⟩
· exact continuous_euclidean_to_deltaGenerated.mpr p.2
· exact continuous_euclidean_to_deltaGenerated.mp <| @ContinuousMap.continuous_toFun _ _ _ (_) p | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | deltaGenerated_deltaGenerated_eq | `deltaGenerated` is idempotent as a function `TopologicalSpace X → TopologicalSpace X`. |
DeltaGeneratedSpace (X : Type*) [t : TopologicalSpace X] : Prop where
le_deltaGenerated : t ≤ deltaGenerated X | class | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | DeltaGeneratedSpace | A space is delta-generated if its topology is equal to the delta-generated topology, i.e.
coinduced by all continuous maps ℝⁿ → X. Since the delta-generated topology is always finer
than the original one, it suffices to show that it is also coarser. |
eq_deltaGenerated [DeltaGeneratedSpace X] : tX = deltaGenerated X :=
eq_of_le_of_ge DeltaGeneratedSpace.le_deltaGenerated deltaGenerated_le | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | eq_deltaGenerated | null |
DeltaGeneratedSpace.isOpen_iff [DeltaGeneratedSpace X] {u : Set X} :
IsOpen u ↔ ∀ (n : ℕ) (p : ContinuousMap ((Fin n) → ℝ) X), IsOpen (p ⁻¹' u) := by
nth_rewrite 1 [eq_deltaGenerated (X := X)]; exact isOpen_deltaGenerated_iff | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | DeltaGeneratedSpace.isOpen_iff | A subset of a delta-generated space is open iff its preimage is open for every
continuous map from ℝⁿ to X. |
DeltaGeneratedSpace.continuous_iff [DeltaGeneratedSpace X] {f : X → Y} :
Continuous f ↔ ∀ (n : ℕ) (p : C(((Fin n) → ℝ), X)), Continuous (f ∘ p) := by
simp_rw [continuous_iff_coinduced_le]
nth_rewrite 1 [eq_deltaGenerated (X := X), deltaGenerated]
simp [coinduced_compose, Sigma.forall] | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | DeltaGeneratedSpace.continuous_iff | A map out of a delta-generated space is continuous iff it preserves continuity of maps
from ℝⁿ into X. |
continuous_to_deltaGenerated [DeltaGeneratedSpace X] {f : X → Y} :
Continuous[_, deltaGenerated Y] f ↔ Continuous f := by
simp_rw [DeltaGeneratedSpace.continuous_iff, continuous_euclidean_to_deltaGenerated] | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | continuous_to_deltaGenerated | A map out of a delta-generated space is continuous iff it is continuous with respect
to the delta-generated topology on the codomain. |
deltaGeneratedSpace_deltaGenerated {X : Type*} {t : TopologicalSpace X} :
@DeltaGeneratedSpace X (@deltaGenerated X t) := by
let _ := @deltaGenerated X t; constructor; rw [@deltaGenerated_deltaGenerated_eq X t] | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | deltaGeneratedSpace_deltaGenerated | The delta-generated topology on `X` does in fact turn `X` into a delta-generated space. |
deltaGenerated_mono {X : Type*} {t₁ t₂ : TopologicalSpace X} (h : t₁ ≤ t₂) :
@deltaGenerated X t₁ ≤ @deltaGenerated X t₂ := by
rw [← continuous_id_iff_le, @continuous_to_deltaGenerated _ _
(@deltaGenerated X t₁) t₂ deltaGeneratedSpace_deltaGenerated id]
exact continuous_id_iff_le.2 <| (@deltaGenerated_le X t₁).trans h | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | deltaGenerated_mono | null |
of (X : Type*) := X | def | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | of | Type synonym to be equipped with the delta-generated topology. |
counit : (of X) → X := id | def | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | counit | The natural map from `DeltaGeneratedSpace.of X` to `X`. |
continuous_counit : Continuous (counit : _ → X) := by
rw [continuous_iff_coinduced_le]; exact deltaGenerated_le | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | continuous_counit | null |
DeltaGeneratedSpace.coinduced [DeltaGeneratedSpace X] (f : X → Y) :
@DeltaGeneratedSpace Y (tX.coinduced f) :=
let _ := tX.coinduced f
⟨(continuous_to_deltaGenerated.2 continuous_coinduced_rng).coinduced_le⟩ | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | DeltaGeneratedSpace.coinduced | Delta-generated spaces are locally path-connected. -/
instance [DeltaGeneratedSpace X] : LocPathConnectedSpace X := by
rw [eq_deltaGenerated (X := X), deltaGenerated_eq_coinduced]
exact LocPathConnectedSpace.coinduced _
/-- Delta-generated spaces are sequential. -/
instance [DeltaGeneratedSpace X] : SequentialSpace X := by
rw [eq_deltaGenerated (X := X)]
exact SequentialSpace.iSup fun p ↦ SequentialSpace.coinduced p.2
end DeltaGeneratedSpace
omit tY in
/-- Any topology coinduced by a delta-generated topology is delta-generated. |
protected DeltaGeneratedSpace.iSup {X : Type*} {ι : Sort*} {t : ι → TopologicalSpace X}
(h : ∀ i, @DeltaGeneratedSpace X (t i)) : @DeltaGeneratedSpace X (⨆ i, t i) :=
let _ := ⨆ i, t i
⟨iSup_le_iff.2 fun i ↦ (h i).le_deltaGenerated.trans <| deltaGenerated_mono <| le_iSup t i⟩ | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | DeltaGeneratedSpace.iSup | Suprema of delta-generated topologies are delta-generated. |
protected DeltaGeneratedSpace.sup {X : Type*} {t₁ t₂ : TopologicalSpace X}
(h₁ : @DeltaGeneratedSpace X t₁) (h₂ : @DeltaGeneratedSpace X t₂) :
@DeltaGeneratedSpace X (t₁ ⊔ t₂) := by
rw [sup_eq_iSup]
exact .iSup <| Bool.forall_bool.2 ⟨h₂, h₁⟩ | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | DeltaGeneratedSpace.sup | Suprema of delta-generated topologies are delta-generated. |
Topology.IsQuotientMap.deltaGeneratedSpace [DeltaGeneratedSpace X]
{f : X → Y} (h : IsQuotientMap f) : DeltaGeneratedSpace Y :=
h.2 ▸ DeltaGeneratedSpace.coinduced f | lemma | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | Topology.IsQuotientMap.deltaGeneratedSpace | Quotients of delta-generated spaces are delta-generated. |
Quot.deltaGeneratedSpace [DeltaGeneratedSpace X] {r : X → X → Prop} :
DeltaGeneratedSpace (Quot r) :=
isQuotientMap_quot_mk.deltaGeneratedSpace | instance | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | Quot.deltaGeneratedSpace | Quotients of delta-generated spaces are delta-generated. |
Quotient.deltaGeneratedSpace [DeltaGeneratedSpace X] {s : Setoid X} :
DeltaGeneratedSpace (Quotient s) :=
isQuotientMap_quotient_mk'.deltaGeneratedSpace | instance | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | Quotient.deltaGeneratedSpace | Quotients of delta-generated spaces are delta-generated. |
Sum.deltaGeneratedSpace [DeltaGeneratedSpace X] [DeltaGeneratedSpace Y] :
DeltaGeneratedSpace (X ⊕ Y) :=
DeltaGeneratedSpace.sup (.coinduced Sum.inl) (.coinduced Sum.inr) | instance | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | Sum.deltaGeneratedSpace | Disjoint unions of delta-generated spaces are delta-generated. |
Sigma.deltaGeneratedSpace {ι : Type*} {X : ι → Type*} [∀ i, TopologicalSpace (X i)]
[∀ i, DeltaGeneratedSpace (X i)] : DeltaGeneratedSpace (Σ i, X i) :=
.iSup fun _ ↦ .coinduced _ | instance | Topology | [
"Mathlib.Analysis.LocallyConvex.WithSeminorms"
] | Mathlib/Topology/Compactness/DeltaGeneratedSpace.lean | Sigma.deltaGeneratedSpace | Disjoint unions of delta-generated spaces are delta-generated. |
exists_closed_embedding_to_hilbert_cube (X : Type*) [MetricSpace X] [CompactSpace X] :
∃ f : X → (ℕ → unitInterval), Topology.IsClosedEmbedding f := by
obtain _ | _ := subsingleton_or_nontrivial X
· use Function.const _ 0
exact continuous_const.isClosedEmbedding <| Function.injective_of_subsingleton _
let s := TopologicalSpace.denseSeq X
have s_dense : DenseRange s := TopologicalSpace.denseRange_denseSeq X
let diam := Metric.diam (Set.univ : Set X)
have dist_le_diam : ∀ x y, dist x y ≤ diam :=
fun x y ↦ Metric.dist_le_diam_of_mem isCompact_univ.isBounded trivial trivial
have diam_pos : 0 < diam :=
Metric.diam_pos (by rwa [Set.nontrivial_univ_iff]) isCompact_univ.isBounded
let f : X → (ℕ → unitInterval) := fun x i =>
⟨dist x (s i) / diam, by positivity, div_le_one_of_le₀ (dist_le_diam _ _) Metric.diam_nonneg⟩
use f
apply Continuous.isClosedEmbedding
· fun_prop
intro x y hxy
simp only [f] at hxy
suffices dist x y = 0 from eq_of_dist_eq_zero this
suffices dist x = dist y from dist_self y ▸ congrFun this y
apply s_dense.equalizer (by fun_prop) (by fun_prop)
ext i
rw [← div_left_inj' diam_pos.ne']
exact congr(((↑) : unitInterval → ℝ) ($hxy i)) | theorem | Topology | [
"Mathlib.Topology.UnitInterval"
] | Mathlib/Topology/Compactness/HilbertCubeEmbedding.lean | exists_closed_embedding_to_hilbert_cube | Every compact metric space can be embedded into the Hilbert cube. |
IsLindelof (s : Set X) :=
∀ ⦃f⦄ [NeBot f] [CountableInterFilter f], f ≤ 𝓟 s → ∃ x ∈ s, ClusterPt x f | def | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof | A set `s` is Lindelöf if every nontrivial filter `f` with the countable intersection
property that contains `s`, has a clusterpoint in `s`. The filter-free definition is given by
`isLindelof_iff_countable_subcover`. |
IsLindelof.compl_mem_sets (hs : IsLindelof s) {f : Filter X} [CountableInterFilter f]
(hf : ∀ x ∈ s, sᶜ ∈ 𝓝 x ⊓ f) : sᶜ ∈ f := by
contrapose! hf
simp only [notMem_iff_inf_principal_compl, compl_compl, inf_assoc] at hf ⊢
exact hs inf_le_right | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.compl_mem_sets | The complement to a Lindelöf set belongs to a filter `f` with the countable intersection
property if it belongs to each filter `𝓝 x ⊓ f`, `x ∈ s`. |
IsLindelof.compl_mem_sets_of_nhdsWithin (hs : IsLindelof s) {f : Filter X}
[CountableInterFilter f] (hf : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, tᶜ ∈ f) : sᶜ ∈ f := by
refine hs.compl_mem_sets fun x hx ↦ ?_
rw [← disjoint_principal_right, disjoint_right_comm, (basis_sets _).disjoint_iff_left]
exact hf x hx | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.compl_mem_sets_of_nhdsWithin | The complement to a Lindelöf set belongs to a filter `f` with the countable intersection
property if each `x ∈ s` has a neighborhood `t` within `s` such that `tᶜ` belongs to `f`. |
@[elab_as_elim]
IsLindelof.induction_on (hs : IsLindelof s) {p : Set X → Prop}
(hmono : ∀ ⦃s t⦄, s ⊆ t → p t → p s)
(hcountable_union : ∀ (S : Set (Set X)), S.Countable → (∀ s ∈ S, p s) → p (⋃₀ S))
(hnhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, p t) : p s := by
let f : Filter X := ofCountableUnion p hcountable_union (fun t ht _ hsub ↦ hmono hsub ht)
have : sᶜ ∈ f := hs.compl_mem_sets_of_nhdsWithin (by simpa [f] using hnhds)
rwa [← compl_compl s] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.induction_on | If `p : Set X → Prop` is stable under restriction and union, and each point `x`
of a Lindelöf set `s` has a neighborhood `t` within `s` such that `p t`, then `p s` holds. |
IsLindelof.inter_right (hs : IsLindelof s) (ht : IsClosed t) : IsLindelof (s ∩ t) := by
intro f hnf _ hstf
rw [← inf_principal, le_inf_iff] at hstf
obtain ⟨x, hsx, hx⟩ : ∃ x ∈ s, ClusterPt x f := hs hstf.1
have hxt : x ∈ t := ht.mem_of_nhdsWithin_neBot <| hx.mono hstf.2
exact ⟨x, ⟨hsx, hxt⟩, hx⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.inter_right | The intersection of a Lindelöf set and a closed set is a Lindelöf set. |
IsLindelof.inter_left (ht : IsLindelof t) (hs : IsClosed s) : IsLindelof (s ∩ t) :=
inter_comm t s ▸ ht.inter_right hs | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.inter_left | The intersection of a closed set and a Lindelöf set is a Lindelöf set. |
IsLindelof.diff (hs : IsLindelof s) (ht : IsOpen t) : IsLindelof (s \ t) :=
hs.inter_right (isClosed_compl_iff.mpr ht) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.diff | The set difference of a Lindelöf set and an open set is a Lindelöf set. |
IsLindelof.of_isClosed_subset (hs : IsLindelof s) (ht : IsClosed t) (h : t ⊆ s) :
IsLindelof t := inter_eq_self_of_subset_right h ▸ hs.inter_right ht | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.of_isClosed_subset | A closed subset of a Lindelöf set is a Lindelöf set. |
IsLindelof.image_of_continuousOn {f : X → Y} (hs : IsLindelof s) (hf : ContinuousOn f s) :
IsLindelof (f '' s) := by
intro l lne _ ls
have : NeBot (l.comap f ⊓ 𝓟 s) :=
comap_inf_principal_neBot_of_image_mem lne (le_principal_iff.1 ls)
obtain ⟨x, hxs, hx⟩ : ∃ x ∈ s, ClusterPt x (l.comap f ⊓ 𝓟 s) := @hs _ this _ inf_le_right
haveI := hx.neBot
use f x, mem_image_of_mem f hxs
have : Tendsto f (𝓝 x ⊓ (comap f l ⊓ 𝓟 s)) (𝓝 (f x) ⊓ l) := by
convert (hf x hxs).inf (@tendsto_comap _ _ f l) using 1
rw [nhdsWithin]
ac_rfl
exact this.neBot | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.image_of_continuousOn | A continuous image of a Lindelöf set is a Lindelöf set. |
IsLindelof.image {f : X → Y} (hs : IsLindelof s) (hf : Continuous f) :
IsLindelof (f '' s) := hs.image_of_continuousOn hf.continuousOn | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.image | A continuous image of a Lindelöf set is a Lindelöf set within the codomain. |
IsLindelof.adherence_nhdset {f : Filter X} [CountableInterFilter f] (hs : IsLindelof s)
(hf₂ : f ≤ 𝓟 s) (ht₁ : IsOpen t) (ht₂ : ∀ x ∈ s, ClusterPt x f → x ∈ t) : t ∈ f :=
(eq_or_neBot _).casesOn mem_of_eq_bot fun _ ↦
let ⟨x, hx, hfx⟩ := @hs (f ⊓ 𝓟 tᶜ) _ _ <| inf_le_of_left_le hf₂
have : x ∈ t := ht₂ x hx hfx.of_inf_left
have : tᶜ ∩ t ∈ 𝓝[tᶜ] x := inter_mem_nhdsWithin _ (ht₁.mem_nhds this)
have A : 𝓝[tᶜ] x = ⊥ := empty_mem_iff_bot.1 <| compl_inter_self t ▸ this
have : 𝓝[tᶜ] x ≠ ⊥ := hfx.of_inf_right.ne
absurd A this | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.adherence_nhdset | A filter with the countable intersection property that is finer than the principal filter on
a Lindelöf set `s` contains any open set that contains all clusterpoints of `s`. |
IsLindelof.elim_countable_subcover {ι : Type v} (hs : IsLindelof s) (U : ι → Set X)
(hUo : ∀ i, IsOpen (U i)) (hsU : s ⊆ ⋃ i, U i) :
∃ r : Set ι, r.Countable ∧ (s ⊆ ⋃ i ∈ r, U i) := by
have hmono : ∀ ⦃s t : Set X⦄, s ⊆ t → (∃ r : Set ι, r.Countable ∧ t ⊆ ⋃ i ∈ r, U i)
→ (∃ r : Set ι, r.Countable ∧ s ⊆ ⋃ i ∈ r, U i) := by
intro _ _ hst ⟨r, ⟨hrcountable, hsub⟩⟩
exact ⟨r, hrcountable, Subset.trans hst hsub⟩
have hcountable_union : ∀ (S : Set (Set X)), S.Countable
→ (∀ s ∈ S, ∃ r : Set ι, r.Countable ∧ (s ⊆ ⋃ i ∈ r, U i))
→ ∃ r : Set ι, r.Countable ∧ (⋃₀ S ⊆ ⋃ i ∈ r, U i) := by
intro S hS hsr
choose! r hr using hsr
refine ⟨⋃ s ∈ S, r s, hS.biUnion_iff.mpr (fun s hs ↦ (hr s hs).1), ?_⟩
refine sUnion_subset ?h.right.h
simp only [mem_iUnion, exists_prop, iUnion_exists, biUnion_and']
exact fun i is x hx ↦ mem_biUnion is ((hr i is).2 hx)
have h_nhds : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∃ r : Set ι, r.Countable ∧ (t ⊆ ⋃ i ∈ r, U i) := by
intro x hx
let ⟨i, hi⟩ := mem_iUnion.1 (hsU hx)
refine ⟨U i, mem_nhdsWithin_of_mem_nhds ((hUo i).mem_nhds hi), {i}, by simp, ?_⟩
simp only [mem_singleton_iff, iUnion_iUnion_eq_left]
exact Subset.refl _
exact hs.induction_on hmono hcountable_union h_nhds | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.elim_countable_subcover | For every open cover of a Lindelöf set, there exists a countable subcover. |
IsLindelof.elim_nhds_subcover' (hs : IsLindelof s) (U : ∀ x ∈ s, Set X)
(hU : ∀ x (hx : x ∈ s), U x ‹x ∈ s› ∈ 𝓝 x) :
∃ t : Set s, t.Countable ∧ s ⊆ ⋃ x ∈ t, U (x : s) x.2 := by
have := hs.elim_countable_subcover (fun x : s ↦ interior (U x x.2)) (fun _ ↦ isOpen_interior)
fun x hx ↦
mem_iUnion.2 ⟨⟨x, hx⟩, mem_interior_iff_mem_nhds.2 <| hU _ _⟩
rcases this with ⟨r, ⟨hr, hs⟩⟩
use r, hr
apply Subset.trans hs
apply iUnion₂_subset
intro i hi
apply Subset.trans interior_subset
exact subset_iUnion_of_subset i (subset_iUnion_of_subset hi (Subset.refl _)) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.elim_nhds_subcover' | null |
IsLindelof.elim_nhds_subcover (hs : IsLindelof s) (U : X → Set X)
(hU : ∀ x ∈ s, U x ∈ 𝓝 x) :
∃ t : Set X, t.Countable ∧ (∀ x ∈ t, x ∈ s) ∧ s ⊆ ⋃ x ∈ t, U x := by
let ⟨t, ⟨htc, htsub⟩⟩ := hs.elim_nhds_subcover' (fun x _ ↦ U x) hU
refine ⟨↑t, Countable.image htc Subtype.val, ?_⟩
constructor
· intro _
simp only [mem_image, Subtype.exists, exists_and_right, exists_eq_right, forall_exists_index]
tauto
· have : ⋃ x ∈ t, U ↑x = ⋃ x ∈ Subtype.val '' t, U x := biUnion_image.symm
rwa [← this] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.elim_nhds_subcover | null |
IsLindelof.indexed_countable_subcover {ι : Type v} [Nonempty ι]
(hs : IsLindelof s) (U : ι → Set X) (hUo : ∀ i, IsOpen (U i)) (hsU : s ⊆ ⋃ i, U i) :
∃ f : ℕ → ι, s ⊆ ⋃ n, U (f n) := by
obtain ⟨c, ⟨c_count, c_cov⟩⟩ := hs.elim_countable_subcover U hUo hsU
rcases c.eq_empty_or_nonempty with rfl | c_nonempty
· simp only [mem_empty_iff_false, iUnion_of_empty, iUnion_empty] at c_cov
simp only [subset_eq_empty c_cov rfl, empty_subset, exists_const]
obtain ⟨f, f_surj⟩ := (Set.countable_iff_exists_surjective c_nonempty).mp c_count
refine ⟨fun x ↦ f x, c_cov.trans <| iUnion₂_subset_iff.mpr (?_ : ∀ i ∈ c, U i ⊆ ⋃ n, U (f n))⟩
intro x hx
obtain ⟨n, hn⟩ := f_surj ⟨x, hx⟩
exact subset_iUnion_of_subset n <| subset_of_eq (by rw [hn]) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.indexed_countable_subcover | For every nonempty open cover of a Lindelöf set, there exists a subcover indexed by ℕ. |
IsLindelof.disjoint_nhdsSet_left {l : Filter X} [CountableInterFilter l]
(hs : IsLindelof s) :
Disjoint (𝓝ˢ s) l ↔ ∀ x ∈ s, Disjoint (𝓝 x) l := by
refine ⟨fun h x hx ↦ h.mono_left <| nhds_le_nhdsSet hx, fun H ↦ ?_⟩
choose! U hxU hUl using fun x hx ↦ (nhds_basis_opens x).disjoint_iff_left.1 (H x hx)
choose hxU hUo using hxU
rcases hs.elim_nhds_subcover U fun x hx ↦ (hUo x hx).mem_nhds (hxU x hx) with ⟨t, htc, hts, hst⟩
refine (hasBasis_nhdsSet _).disjoint_iff_left.2
⟨⋃ x ∈ t, U x, ⟨isOpen_biUnion fun x hx ↦ hUo x (hts x hx), hst⟩, ?_⟩
rw [compl_iUnion₂]
exact (countable_bInter_mem htc).mpr (fun i hi ↦ hUl _ (hts _ hi)) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.disjoint_nhdsSet_left | The neighborhood filter of a Lindelöf set is disjoint with a filter `l` with the countable
intersection property if and only if the neighborhood filter of each point of this set
is disjoint with `l`. |
IsLindelof.disjoint_nhdsSet_right {l : Filter X} [CountableInterFilter l]
(hs : IsLindelof s) : Disjoint l (𝓝ˢ s) ↔ ∀ x ∈ s, Disjoint l (𝓝 x) := by
simpa only [disjoint_comm] using hs.disjoint_nhdsSet_left | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.disjoint_nhdsSet_right | A filter `l` with the countable intersection property is disjoint with the neighborhood
filter of a Lindelöf set if and only if it is disjoint with the neighborhood filter of each point
of this set. |
IsLindelof.elim_countable_subfamily_closed {ι : Type v} (hs : IsLindelof s)
(t : ι → Set X) (htc : ∀ i, IsClosed (t i)) (hst : (s ∩ ⋂ i, t i) = ∅) :
∃ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i) = ∅ := by
let U := tᶜ
have hUo : ∀ i, IsOpen (U i) := by simp only [U, Pi.compl_apply, isOpen_compl_iff]; exact htc
have hsU : s ⊆ ⋃ i, U i := by
simp only [U, Pi.compl_apply]
rw [← compl_iInter]
apply disjoint_compl_left_iff_subset.mp
simp only [compl_iInter, compl_iUnion, compl_compl]
apply Disjoint.symm
exact disjoint_iff_inter_eq_empty.mpr hst
rcases hs.elim_countable_subcover U hUo hsU with ⟨u, ⟨hucount, husub⟩⟩
use u, hucount
rw [← disjoint_compl_left_iff_subset] at husub
simp only [U, Pi.compl_apply, compl_iUnion, compl_compl] at husub
exact disjoint_iff_inter_eq_empty.mp (Disjoint.symm husub) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.elim_countable_subfamily_closed | For every family of closed sets whose intersection avoids a Lindelöf set,
there exists a countable subfamily whose intersection avoids this Lindelöf set. |
IsLindelof.inter_iInter_nonempty {ι : Type v} (hs : IsLindelof s) (t : ι → Set X)
(htc : ∀ i, IsClosed (t i)) (hst : ∀ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i).Nonempty) :
(s ∩ ⋂ i, t i).Nonempty := by
contrapose! hst
rcases hs.elim_countable_subfamily_closed t htc hst with ⟨u, ⟨_, husub⟩⟩
exact ⟨u, fun _ ↦ husub⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.inter_iInter_nonempty | To show that a Lindelöf set intersects the intersection of a family of closed sets,
it is sufficient to show that it intersects every countable subfamily. |
IsLindelof.elim_countable_subcover_image {b : Set ι} {c : ι → Set X} (hs : IsLindelof s)
(hc₁ : ∀ i ∈ b, IsOpen (c i)) (hc₂ : s ⊆ ⋃ i ∈ b, c i) :
∃ b', b' ⊆ b ∧ Set.Countable b' ∧ s ⊆ ⋃ i ∈ b', c i := by
simp only [Subtype.forall', biUnion_eq_iUnion] at hc₁ hc₂
rcases hs.elim_countable_subcover (fun i ↦ c i : b → Set X) hc₁ hc₂ with ⟨d, hd⟩
refine ⟨Subtype.val '' d, by simp, Countable.image hd.1 Subtype.val, ?_⟩
rw [biUnion_image]
exact hd.2 | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.elim_countable_subcover_image | For every open cover of a Lindelöf set, there exists a countable subcover. |
isLindelof_of_countable_subcover
(h : ∀ {ι : Type u} (U : ι → Set X), (∀ i, IsOpen (U i)) → (s ⊆ ⋃ i, U i) →
∃ t : Set ι, t.Countable ∧ s ⊆ ⋃ i ∈ t, U i) :
IsLindelof s := fun f hf hfs ↦ by
contrapose! h
simp only [ClusterPt, not_neBot, ← disjoint_iff, SetCoe.forall',
(nhds_basis_opens _).disjoint_iff_left] at h
choose fsub U hU hUf using h
refine ⟨s, U, fun x ↦ (hU x).2, fun x hx ↦ mem_iUnion.2 ⟨⟨x, hx⟩, (hU _).1 ⟩, ?_⟩
intro t ht h
have uinf := f.sets_of_superset (le_principal_iff.1 fsub) h
have uninf : ⋂ i ∈ t, (U i)ᶜ ∈ f := (countable_bInter_mem ht).mpr (fun _ _ ↦ hUf _)
rw [← compl_iUnion₂] at uninf
have uninf := compl_notMem uninf
simp only [compl_compl] at uninf
contradiction | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_of_countable_subcover | A set `s` is Lindelöf if for every open cover of `s`, there exists a countable subcover. |
isLindelof_of_countable_subfamily_closed
(h :
∀ {ι : Type u} (t : ι → Set X), (∀ i, IsClosed (t i)) → (s ∩ ⋂ i, t i) = ∅ →
∃ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i) = ∅) :
IsLindelof s :=
isLindelof_of_countable_subcover fun U hUo hsU ↦ by
rw [← disjoint_compl_right_iff_subset, compl_iUnion, disjoint_iff] at hsU
rcases h (fun i ↦ (U i)ᶜ) (fun i ↦ (hUo _).isClosed_compl) hsU with ⟨t, ht⟩
refine ⟨t, ?_⟩
rwa [← disjoint_compl_right_iff_subset, compl_iUnion₂, disjoint_iff] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_of_countable_subfamily_closed | A set `s` is Lindelöf if for every family of closed sets whose intersection avoids `s`,
there exists a countable subfamily whose intersection avoids `s`. |
isLindelof_iff_countable_subcover :
IsLindelof s ↔ ∀ {ι : Type u} (U : ι → Set X),
(∀ i, IsOpen (U i)) → (s ⊆ ⋃ i, U i) → ∃ t : Set ι, t.Countable ∧ s ⊆ ⋃ i ∈ t, U i :=
⟨fun hs ↦ hs.elim_countable_subcover, isLindelof_of_countable_subcover⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_iff_countable_subcover | A set `s` is Lindelöf if and only if
for every open cover of `s`, there exists a countable subcover. |
isLindelof_iff_countable_subfamily_closed :
IsLindelof s ↔ ∀ {ι : Type u} (t : ι → Set X),
(∀ i, IsClosed (t i)) → (s ∩ ⋂ i, t i) = ∅
→ ∃ u : Set ι, u.Countable ∧ (s ∩ ⋂ i ∈ u, t i) = ∅ :=
⟨fun hs ↦ hs.elim_countable_subfamily_closed, isLindelof_of_countable_subfamily_closed⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_iff_countable_subfamily_closed | A set `s` is Lindelöf if and only if
for every family of closed sets whose intersection avoids `s`,
there exists a countable subfamily whose intersection avoids `s`. |
@[simp]
isLindelof_empty : IsLindelof (∅ : Set X) := fun _f hnf _ hsf ↦
Not.elim hnf.ne <| empty_mem_iff_bot.1 <| le_principal_iff.1 hsf | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_empty | The empty set is a Lindelof set. |
@[simp]
isLindelof_singleton {x : X} : IsLindelof ({x} : Set X) := fun _ hf _ hfa ↦
⟨x, rfl, ClusterPt.of_le_nhds'
(hfa.trans <| by simpa only [principal_singleton] using pure_le_nhds x) hf⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_singleton | A singleton set is a Lindelof set. |
Set.Subsingleton.isLindelof (hs : s.Subsingleton) : IsLindelof s :=
Subsingleton.induction_on hs isLindelof_empty fun _ ↦ isLindelof_singleton | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Set.Subsingleton.isLindelof | null |
Set.Countable.isLindelof_biUnion {s : Set ι} {f : ι → Set X} (hs : s.Countable)
(hf : ∀ i ∈ s, IsLindelof (f i)) : IsLindelof (⋃ i ∈ s, f i) := by
apply isLindelof_of_countable_subcover
intro i U hU hUcover
have hiU : ∀ i ∈ s, f i ⊆ ⋃ i, U i :=
fun _ is ↦ _root_.subset_trans (subset_biUnion_of_mem is) hUcover
have iSets := fun i is ↦ (hf i is).elim_countable_subcover U hU (hiU i is)
choose! r hr using iSets
use ⋃ i ∈ s, r i
constructor
· refine (Countable.biUnion_iff hs).mpr ?h.left.a
exact fun s hs ↦ (hr s hs).1
· refine iUnion₂_subset ?h.right.h
intro i is
simp only [mem_iUnion, exists_prop, iUnion_exists, biUnion_and']
intro x hx
exact mem_biUnion is ((hr i is).2 hx) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Set.Countable.isLindelof_biUnion | null |
Set.Finite.isLindelof_biUnion {s : Set ι} {f : ι → Set X} (hs : s.Finite)
(hf : ∀ i ∈ s, IsLindelof (f i)) : IsLindelof (⋃ i ∈ s, f i) :=
Set.Countable.isLindelof_biUnion (countable hs) hf | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Set.Finite.isLindelof_biUnion | null |
Finset.isLindelof_biUnion (s : Finset ι) {f : ι → Set X} (hf : ∀ i ∈ s, IsLindelof (f i)) :
IsLindelof (⋃ i ∈ s, f i) :=
s.finite_toSet.isLindelof_biUnion hf | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Finset.isLindelof_biUnion | null |
isLindelof_accumulate {K : ℕ → Set X} (hK : ∀ n, IsLindelof (K n)) (n : ℕ) :
IsLindelof (Accumulate K n) :=
(finite_le_nat n).isLindelof_biUnion fun k _ => hK k | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_accumulate | null |
Set.Countable.isLindelof_sUnion {S : Set (Set X)} (hf : S.Countable)
(hc : ∀ s ∈ S, IsLindelof s) : IsLindelof (⋃₀ S) := by
rw [sUnion_eq_biUnion]; exact hf.isLindelof_biUnion hc | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Set.Countable.isLindelof_sUnion | null |
Set.Finite.isLindelof_sUnion {S : Set (Set X)} (hf : S.Finite)
(hc : ∀ s ∈ S, IsLindelof s) : IsLindelof (⋃₀ S) := by
rw [sUnion_eq_biUnion]; exact hf.isLindelof_biUnion hc | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Set.Finite.isLindelof_sUnion | null |
isLindelof_iUnion {ι : Sort*} {f : ι → Set X} [Countable ι] (h : ∀ i, IsLindelof (f i)) :
IsLindelof (⋃ i, f i) := (countable_range f).isLindelof_sUnion <| forall_mem_range.2 h | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_iUnion | null |
Set.Countable.isLindelof (hs : s.Countable) : IsLindelof s :=
biUnion_of_singleton s ▸ hs.isLindelof_biUnion fun _ _ => isLindelof_singleton | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Set.Countable.isLindelof | null |
Set.Finite.isLindelof (hs : s.Finite) : IsLindelof s :=
biUnion_of_singleton s ▸ hs.isLindelof_biUnion fun _ _ => isLindelof_singleton | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Set.Finite.isLindelof | null |
IsLindelof.countable_of_discrete [DiscreteTopology X] (hs : IsLindelof s) :
s.Countable := by
have : ∀ x : X, ({x} : Set X) ∈ 𝓝 x := by simp [nhds_discrete]
rcases hs.elim_nhds_subcover (fun x => {x}) fun x _ => this x with ⟨t, ht, _, hssubt⟩
rw [biUnion_of_singleton] at hssubt
exact ht.mono hssubt | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.countable_of_discrete | null |
isLindelof_iff_countable [DiscreteTopology X] : IsLindelof s ↔ s.Countable :=
⟨fun h => h.countable_of_discrete, fun h => h.isLindelof⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_iff_countable | null |
IsLindelof.union (hs : IsLindelof s) (ht : IsLindelof t) : IsLindelof (s ∪ t) := by
rw [union_eq_iUnion]; exact isLindelof_iUnion fun b => by cases b <;> assumption | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.union | null |
protected IsLindelof.insert (hs : IsLindelof s) (a) : IsLindelof (insert a s) :=
isLindelof_singleton.union hs | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.insert | null |
isLindelof_open_iff_eq_countable_iUnion_of_isTopologicalBasis (b : ι → Set X)
(hb : IsTopologicalBasis (Set.range b)) (hb' : ∀ i, IsLindelof (b i)) (U : Set X) :
IsLindelof U ∧ IsOpen U ↔ ∃ s : Set ι, s.Countable ∧ U = ⋃ i ∈ s, b i := by
constructor
· rintro ⟨h₁, h₂⟩
obtain ⟨Y, f, rfl, hf⟩ := hb.open_eq_iUnion h₂
choose f' hf' using hf
have : b ∘ f' = f := funext hf'
subst this
obtain ⟨t, ht⟩ :=
h₁.elim_countable_subcover (b ∘ f') (fun i => hb.isOpen (Set.mem_range_self _)) Subset.rfl
refine ⟨t.image f', Countable.image (ht.1) f', le_antisymm ?_ ?_⟩
· refine Set.Subset.trans ht.2 ?_
simp only [Set.iUnion_subset_iff]
intro i hi
rw [← Set.iUnion_subtype (fun x : ι => x ∈ t.image f') fun i => b i.1]
exact Set.subset_iUnion (fun i : t.image f' => b i) ⟨_, mem_image_of_mem _ hi⟩
· apply Set.iUnion₂_subset
rintro i hi
obtain ⟨j, -, rfl⟩ := (mem_image ..).mp hi
exact Set.subset_iUnion (b ∘ f') j
· rintro ⟨s, hs, rfl⟩
constructor
· exact hs.isLindelof_biUnion fun i _ => hb' i
· exact isOpen_biUnion fun i _ => hb.isOpen (Set.mem_range_self _) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_open_iff_eq_countable_iUnion_of_isTopologicalBasis | If `X` has a basis consisting of compact opens, then an open set in `X` is compact open iff
it is a finite union of some elements in the basis |
Filter.coLindelof (X : Type*) [TopologicalSpace X] : Filter X :=
⨅ (s : Set X) (_ : IsLindelof s), 𝓟 sᶜ | def | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Filter.coLindelof | `Filter.coLindelof` is the filter generated by complements to Lindelöf sets. |
hasBasis_coLindelof : (coLindelof X).HasBasis IsLindelof compl :=
hasBasis_biInf_principal'
(fun s hs t ht =>
⟨s ∪ t, hs.union ht, compl_subset_compl.2 subset_union_left,
compl_subset_compl.2 subset_union_right⟩)
⟨∅, isLindelof_empty⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | hasBasis_coLindelof | null |
mem_coLindelof : s ∈ coLindelof X ↔ ∃ t, IsLindelof t ∧ tᶜ ⊆ s :=
hasBasis_coLindelof.mem_iff | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | mem_coLindelof | null |
mem_coLindelof' : s ∈ coLindelof X ↔ ∃ t, IsLindelof t ∧ sᶜ ⊆ t :=
mem_coLindelof.trans <| exists_congr fun _ => and_congr_right fun _ => compl_subset_comm | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | mem_coLindelof' | null |
_root_.IsLindelof.compl_mem_coLindelof (hs : IsLindelof s) : sᶜ ∈ coLindelof X :=
hasBasis_coLindelof.mem_of_mem hs | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | _root_.IsLindelof.compl_mem_coLindelof | null |
coLindelof_le_cofinite : coLindelof X ≤ cofinite := fun s hs =>
compl_compl s ▸ hs.isLindelof.compl_mem_coLindelof | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | coLindelof_le_cofinite | null |
Tendsto.isLindelof_insert_range_of_coLindelof {f : X → Y} {y}
(hf : Tendsto f (coLindelof X) (𝓝 y)) (hfc : Continuous f) :
IsLindelof (insert y (range f)) := by
intro l hne _ hle
by_cases hy : ClusterPt y l
· exact ⟨y, Or.inl rfl, hy⟩
simp only [clusterPt_iff_nonempty, not_forall, ← not_disjoint_iff_nonempty_inter, not_not] at hy
rcases hy with ⟨s, hsy, t, htl, hd⟩
rcases mem_coLindelof.1 (hf hsy) with ⟨K, hKc, hKs⟩
have : f '' K ∈ l := by
filter_upwards [htl, le_principal_iff.1 hle] with y hyt hyf
rcases hyf with (rfl | ⟨x, rfl⟩)
exacts [(hd.le_bot ⟨mem_of_mem_nhds hsy, hyt⟩).elim,
mem_image_of_mem _ (not_not.1 fun hxK => hd.le_bot ⟨hKs hxK, hyt⟩)]
rcases hKc.image hfc (le_principal_iff.2 this) with ⟨y, hy, hyl⟩
exact ⟨y, Or.inr <| image_subset_range _ _ hy, hyl⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Tendsto.isLindelof_insert_range_of_coLindelof | null |
Filter.coclosedLindelof (X : Type*) [TopologicalSpace X] : Filter X :=
⨅ (s : Set X) (_ : IsClosed s) (_ : IsLindelof s), 𝓟 sᶜ | def | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Filter.coclosedLindelof | `Filter.coclosedLindelof` is the filter generated by complements to closed Lindelof sets. |
hasBasis_coclosedLindelof :
(Filter.coclosedLindelof X).HasBasis (fun s => IsClosed s ∧ IsLindelof s) compl := by
simp only [Filter.coclosedLindelof, iInf_and']
refine hasBasis_biInf_principal' ?_ ⟨∅, isClosed_empty, isLindelof_empty⟩
rintro s ⟨hs₁, hs₂⟩ t ⟨ht₁, ht₂⟩
exact ⟨s ∪ t, ⟨⟨hs₁.union ht₁, hs₂.union ht₂⟩, compl_subset_compl.2 subset_union_left,
compl_subset_compl.2 subset_union_right⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | hasBasis_coclosedLindelof | null |
mem_coclosedLindelof : s ∈ coclosedLindelof X ↔
∃ t, IsClosed t ∧ IsLindelof t ∧ tᶜ ⊆ s := by
simp only [hasBasis_coclosedLindelof.mem_iff, and_assoc] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | mem_coclosedLindelof | null |
mem_coclosed_Lindelof' : s ∈ coclosedLindelof X ↔
∃ t, IsClosed t ∧ IsLindelof t ∧ sᶜ ⊆ t := by
simp only [mem_coclosedLindelof, compl_subset_comm] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | mem_coclosed_Lindelof' | null |
coLindelof_le_coclosedLindelof : coLindelof X ≤ coclosedLindelof X :=
iInf_mono fun _ => le_iInf fun _ => le_rfl | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | coLindelof_le_coclosedLindelof | null |
IsLindeof.compl_mem_coclosedLindelof_of_isClosed (hs : IsLindelof s) (hs' : IsClosed s) :
sᶜ ∈ Filter.coclosedLindelof X :=
hasBasis_coclosedLindelof.mem_of_mem ⟨hs', hs⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindeof.compl_mem_coclosedLindelof_of_isClosed | null |
LindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- In a Lindelöf space, `Set.univ` is a Lindelöf set. -/
isLindelof_univ : IsLindelof (univ : Set X) | class | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | LindelofSpace | X is a Lindelöf space iff every open cover has a countable subcover. |
isLindelof_univ_iff : IsLindelof (univ : Set X) ↔ LindelofSpace X :=
⟨fun h => ⟨h⟩, fun h => h.1⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_univ_iff | null |
isLindelof_univ [h : LindelofSpace X] : IsLindelof (univ : Set X) :=
h.isLindelof_univ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_univ | null |
cluster_point_of_Lindelof [LindelofSpace X] (f : Filter X) [NeBot f]
[CountableInterFilter f] : ∃ x, ClusterPt x f := by
simpa using isLindelof_univ (show f ≤ 𝓟 univ by simp) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | cluster_point_of_Lindelof | null |
LindelofSpace.elim_nhds_subcover [LindelofSpace X] (U : X → Set X) (hU : ∀ x, U x ∈ 𝓝 x) :
∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, U x = univ := by
obtain ⟨t, tc, -, s⟩ := IsLindelof.elim_nhds_subcover isLindelof_univ U fun x _ => hU x
use t, tc
apply top_unique s | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | LindelofSpace.elim_nhds_subcover | null |
lindelofSpace_of_countable_subfamily_closed
(h : ∀ {ι : Type u} (t : ι → Set X), (∀ i, IsClosed (t i)) → ⋂ i, t i = ∅ →
∃ u : Set ι, u.Countable ∧ ⋂ i ∈ u, t i = ∅) :
LindelofSpace X where
isLindelof_univ := isLindelof_of_countable_subfamily_closed fun t => by simpa using h t | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | lindelofSpace_of_countable_subfamily_closed | null |
IsClosed.isLindelof [LindelofSpace X] (h : IsClosed s) : IsLindelof s :=
isLindelof_univ.of_isClosed_subset h (subset_univ _) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsClosed.isLindelof | null |
IsCompact.isLindelof (hs : IsCompact s) :
IsLindelof s := by tauto | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsCompact.isLindelof | A compact set `s` is Lindelöf. |
IsSigmaCompact.isLindelof (hs : IsSigmaCompact s) :
IsLindelof s := by
rw [IsSigmaCompact] at hs
rcases hs with ⟨K, ⟨hc, huniv⟩⟩
rw [← huniv]
have hl : ∀ n, IsLindelof (K n) := fun n ↦ IsCompact.isLindelof (hc n)
exact isLindelof_iUnion hl | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsSigmaCompact.isLindelof | A σ-compact set `s` is Lindelöf |
NonLindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- In a non-Lindelöf space, `Set.univ` is not a Lindelöf set. -/
nonLindelof_univ : ¬IsLindelof (univ : Set X) | class | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | NonLindelofSpace | A compact space `X` is Lindelöf. -/
instance (priority := 100) [CompactSpace X] : LindelofSpace X :=
{ isLindelof_univ := isCompact_univ.isLindelof}
/-- A sigma-compact space `X` is Lindelöf. -/
instance (priority := 100) [SigmaCompactSpace X] : LindelofSpace X :=
{ isLindelof_univ := isSigmaCompact_univ.isLindelof}
/-- `X` is a non-Lindelöf topological space if it is not a Lindelöf space. |
nonLindelof_univ (X : Type*) [TopologicalSpace X] [NonLindelofSpace X] :
¬IsLindelof (univ : Set X) :=
NonLindelofSpace.nonLindelof_univ | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | nonLindelof_univ | null |
IsLindelof.ne_univ [NonLindelofSpace X] (hs : IsLindelof s) : s ≠ univ := fun h ↦
nonLindelof_univ X (h ▸ hs) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.ne_univ | null |
@[simp]
Filter.coLindelof_eq_bot [LindelofSpace X] : Filter.coLindelof X = ⊥ :=
hasBasis_coLindelof.eq_bot_iff.mpr ⟨Set.univ, isLindelof_univ, Set.compl_univ⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Filter.coLindelof_eq_bot | null |
nonLindelofSpace_of_neBot (_ : NeBot (Filter.coLindelof X)) : NonLindelofSpace X :=
⟨fun h' => (Filter.nonempty_of_mem h'.compl_mem_coLindelof).ne_empty compl_univ⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | nonLindelofSpace_of_neBot | null |
Filter.coLindelof_neBot_iff : NeBot (Filter.coLindelof X) ↔ NonLindelofSpace X :=
⟨nonLindelofSpace_of_neBot, fun _ => inferInstance⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Filter.coLindelof_neBot_iff | null |
not_LindelofSpace_iff : ¬LindelofSpace X ↔ NonLindelofSpace X :=
⟨fun h₁ => ⟨fun h₂ => h₁ ⟨h₂⟩⟩, fun ⟨h₁⟩ ⟨h₂⟩ => h₁ h₂⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | not_LindelofSpace_iff | null |
countable_of_Lindelof_of_discrete [LindelofSpace X] [DiscreteTopology X] : Countable X :=
countable_univ_iff.mp isLindelof_univ.countable_of_discrete | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | countable_of_Lindelof_of_discrete | null |
countable_cover_nhds_interior [LindelofSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, interior (U x) = univ :=
let ⟨t, ht⟩ := isLindelof_univ.elim_countable_subcover (fun x => interior (U x))
(fun _ => isOpen_interior) fun x _ => mem_iUnion.2 ⟨x, mem_interior_iff_mem_nhds.2 (hU x)⟩
⟨t, ⟨ht.1, univ_subset_iff.1 ht.2⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | countable_cover_nhds_interior | null |
countable_cover_nhds [LindelofSpace X] {U : X → Set X} (hU : ∀ x, U x ∈ 𝓝 x) :
∃ t : Set X, t.Countable ∧ ⋃ x ∈ t, U x = univ :=
let ⟨t, ht⟩ := countable_cover_nhds_interior hU
⟨t, ⟨ht.1, univ_subset_iff.1 <| ht.2.symm.subset.trans <|
iUnion₂_mono fun _ _ => interior_subset⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | countable_cover_nhds | null |
Filter.comap_coLindelof_le {f : X → Y} (hf : Continuous f) :
(Filter.coLindelof Y).comap f ≤ Filter.coLindelof X := by
rw [(hasBasis_coLindelof.comap f).le_basis_iff hasBasis_coLindelof]
intro t ht
refine ⟨f '' t, ht.image hf, ?_⟩
simpa using t.subset_preimage_image f | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Filter.comap_coLindelof_le | The comap of the coLindelöf filter on `Y` by a continuous function `f : X → Y` is less than or
equal to the coLindelöf filter on `X`.
This is a reformulation of the fact that images of Lindelöf sets are Lindelöf. |
isLindelof_range [LindelofSpace X] {f : X → Y} (hf : Continuous f) :
IsLindelof (range f) := by rw [← image_univ]; exact isLindelof_univ.image hf | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_range | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.