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 ⌀ |
|---|---|---|---|---|---|---|
isLindelof_diagonal [LindelofSpace X] : IsLindelof (diagonal X) :=
@range_diag X ▸ isLindelof_range (continuous_id.prodMk continuous_id) | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_diagonal | null |
Topology.IsInducing.isLindelof_iff {f : X → Y} (hf : IsInducing f) :
IsLindelof s ↔ IsLindelof (f '' s) := by
refine ⟨fun hs => hs.image hf.continuous, fun hs F F_ne_bot _ F_le => ?_⟩
obtain ⟨_, ⟨x, x_in : x ∈ s, rfl⟩, hx : ClusterPt (f x) (map f F)⟩ :=
hs ((map_mono F_le).trans_eq map_principal)
exact ⟨x, x_in, hf.mapClusterPt_iff.1 hx⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Topology.IsInducing.isLindelof_iff | If `f : X → Y` is an inducing map, the image `f '' s` of a set `s` is Lindelöf
if and only if `s` is compact. |
Topology.IsEmbedding.isLindelof_iff {f : X → Y} (hf : IsEmbedding f) :
IsLindelof s ↔ IsLindelof (f '' s) := hf.isInducing.isLindelof_iff | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Topology.IsEmbedding.isLindelof_iff | If `f : X → Y` is an embedding, the image `f '' s` of a set `s` is Lindelöf
if and only if `s` is Lindelöf. |
Topology.IsInducing.isLindelof_preimage {f : X → Y} (hf : IsInducing f)
(hf' : IsClosed (range f)) {K : Set Y} (hK : IsLindelof K) : IsLindelof (f ⁻¹' K) := by
replace hK := hK.inter_right hf'
rwa [hf.isLindelof_iff, image_preimage_eq_inter_range] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Topology.IsInducing.isLindelof_preimage | The preimage of a Lindelöf set under an inducing map is a Lindelöf set. |
Topology.IsClosedEmbedding.isLindelof_preimage {f : X → Y} (hf : IsClosedEmbedding f)
{K : Set Y} (hK : IsLindelof K) : IsLindelof (f ⁻¹' K) :=
hf.isInducing.isLindelof_preimage (hf.isClosed_range) hK | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Topology.IsClosedEmbedding.isLindelof_preimage | The preimage of a Lindelöf set under a closed embedding is a Lindelöf set. |
Topology.IsClosedEmbedding.tendsto_coLindelof {f : X → Y} (hf : IsClosedEmbedding f) :
Tendsto f (Filter.coLindelof X) (Filter.coLindelof Y) :=
hasBasis_coLindelof.tendsto_right_iff.mpr fun _K hK =>
(hf.isLindelof_preimage hK).compl_mem_coLindelof | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Topology.IsClosedEmbedding.tendsto_coLindelof | A closed embedding is proper, i.e., inverse images of Lindelöf sets are contained in Lindelöf.
Moreover, the preimage of a Lindelöf set is Lindelöf, see
`Topology.IsClosedEmbedding.isLindelof_preimage`. |
Subtype.isLindelof_iff {p : X → Prop} {s : Set { x // p x }} :
IsLindelof s ↔ IsLindelof ((↑) '' s : Set X) :=
IsEmbedding.subtypeVal.isLindelof_iff | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Subtype.isLindelof_iff | Sets of subtype are Lindelöf iff the image under a coercion is. |
isLindelof_iff_isLindelof_univ : IsLindelof s ↔ IsLindelof (univ : Set s) := by
rw [Subtype.isLindelof_iff, image_univ, Subtype.range_coe] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_iff_isLindelof_univ | null |
isLindelof_iff_LindelofSpace : IsLindelof s ↔ LindelofSpace s :=
isLindelof_iff_isLindelof_univ.trans isLindelof_univ_iff | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | isLindelof_iff_LindelofSpace | null |
IsLindelof.of_coe [LindelofSpace s] : IsLindelof s := isLindelof_iff_LindelofSpace.mpr ‹_› | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.of_coe | null |
IsLindelof.countable (hs : IsLindelof s) (hs' : DiscreteTopology s) : s.Countable :=
countable_coe_iff.mp
(@countable_of_Lindelof_of_discrete _ _ (isLindelof_iff_LindelofSpace.mp hs) hs') | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsLindelof.countable | null |
protected Topology.IsClosedEmbedding.nonLindelofSpace [NonLindelofSpace X] {f : X → Y}
(hf : IsClosedEmbedding f) : NonLindelofSpace Y :=
nonLindelofSpace_of_neBot hf.tendsto_coLindelof.neBot | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Topology.IsClosedEmbedding.nonLindelofSpace | null |
protected Topology.IsClosedEmbedding.LindelofSpace [h : LindelofSpace Y] {f : X → Y}
(hf : IsClosedEmbedding f) : LindelofSpace X :=
⟨by rw [hf.isInducing.isLindelof_iff, image_univ]; exact hf.isClosed_range.isLindelof⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | Topology.IsClosedEmbedding.LindelofSpace | null |
LindelofSpace.of_continuous_surjective {f : X → Y} [LindelofSpace X] (hf : Continuous f)
(hsur : Function.Surjective f) : LindelofSpace Y where
isLindelof_univ := by
rw [← Set.image_univ_of_surjective hsur]
exact IsLindelof.image (isLindelof_univ_iff.mpr ‹_›) hf | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | LindelofSpace.of_continuous_surjective | Countable topological spaces are Lindelof. -/
instance (priority := 100) Countable.LindelofSpace [Countable X] : LindelofSpace X where
isLindelof_univ := countable_univ.isLindelof
/-- The disjoint union of two Lindelöf spaces is Lindelöf. -/
instance [LindelofSpace X] [LindelofSpace Y] : LindelofSpace (X ⊕ Y) where
isLindelof_univ := by
rw [← range_inl_union_range_inr]
exact (isLindelof_range continuous_inl).union (isLindelof_range continuous_inr)
instance {X : ι → Type*} [Countable ι] [∀ i, TopologicalSpace (X i)] [∀ i, LindelofSpace (X i)] :
LindelofSpace (Σ i, X i) where
isLindelof_univ := by
rw [Sigma.univ]
exact isLindelof_iUnion fun i => isLindelof_range continuous_sigmaMk
instance Quot.LindelofSpace {r : X → X → Prop} [LindelofSpace X] : LindelofSpace (Quot r) where
isLindelof_univ := by
rw [← range_quot_mk]
exact isLindelof_range continuous_quot_mk
instance Quotient.LindelofSpace {s : Setoid X} [LindelofSpace X] : LindelofSpace (Quotient s) :=
Quot.LindelofSpace
/-- A continuous image of a Lindelöf set is a Lindelöf set within the codomain. |
IsHereditarilyLindelof (s : Set X) :=
∀ t ⊆ s, IsLindelof t | def | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsHereditarilyLindelof | A set `s` is Hereditarily Lindelöf if every subset is a Lindelof set. We require this only
for open sets in the definition, and then conclude that this holds for all sets by ADD. |
HereditarilyLindelofSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- In a Hereditarily Lindelöf space, `Set.univ` is a Hereditarily Lindelöf set. -/
isHereditarilyLindelof_univ : IsHereditarilyLindelof (univ : Set X) | class | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | HereditarilyLindelofSpace | Type class for Hereditarily Lindelöf spaces. |
IsHereditarilyLindelof.isLindelof_subset (hs : IsHereditarilyLindelof s) (ht : t ⊆ s) :
IsLindelof t := hs t ht | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsHereditarilyLindelof.isLindelof_subset | null |
IsHereditarilyLindelof.isLindelof (hs : IsHereditarilyLindelof s) :
IsLindelof s := hs.isLindelof_subset Subset.rfl | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | IsHereditarilyLindelof.isLindelof | null |
HereditarilyLindelof_LindelofSets [HereditarilyLindelofSpace X] (s : Set X) :
IsLindelof s := by
apply HereditarilyLindelofSpace.isHereditarilyLindelof_univ
exact subset_univ s | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | HereditarilyLindelof_LindelofSets | null |
eq_open_union_countable [HereditarilyLindelofSpace X] {ι : Type u} (U : ι → Set X)
(h : ∀ i, IsOpen (U i)) : ∃ t : Set ι, t.Countable ∧ ⋃ i∈t, U i = ⋃ i, U i := by
have : IsLindelof (⋃ i, U i) := HereditarilyLindelof_LindelofSets (⋃ i, U i)
rcases isLindelof_iff_countable_subcover.mp this U h (Eq.subset rfl) with ⟨t, ⟨htc, htu⟩⟩
use t, htc
apply eq_of_subset_of_subset (iUnion₂_subset_iUnion (fun i ↦ i ∈ t) fun i ↦ U i) htu | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | eq_open_union_countable | null |
HereditarilyLindelof.lindelofSpace_subtype [HereditarilyLindelofSpace X] (p : X → Prop) :
LindelofSpace {x // p x} := by
apply isLindelof_iff_LindelofSpace.mp
exact HereditarilyLindelof_LindelofSets fun x ↦ p x | instance | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Order.Filter.CountableInter",
"Mathlib.Topology.Compactness.SigmaCompact"
] | Mathlib/Topology/Compactness/Lindelof.lean | HereditarilyLindelof.lindelofSpace_subtype | null |
protected Topology.IsClosedEmbedding.weaklyLocallyCompactSpace [WeaklyLocallyCompactSpace Y]
{f : X → Y} (hf : IsClosedEmbedding f) : WeaklyLocallyCompactSpace X where
exists_compact_mem_nhds x :=
let ⟨K, hK, hKx⟩ := exists_compact_mem_nhds (f x)
⟨f ⁻¹' K, hf.isCompact_preimage hK, hf.continuous.continuousAt hKx⟩ | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Topology.IsClosedEmbedding.weaklyLocallyCompactSpace | null |
protected IsClosed.weaklyLocallyCompactSpace [WeaklyLocallyCompactSpace X]
{s : Set X} (hs : IsClosed s) : WeaklyLocallyCompactSpace s :=
hs.isClosedEmbedding_subtypeVal.weaklyLocallyCompactSpace | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | IsClosed.weaklyLocallyCompactSpace | null |
IsOpenQuotientMap.weaklyLocallyCompactSpace [WeaklyLocallyCompactSpace X]
{f : X → Y} (hf : IsOpenQuotientMap f) : WeaklyLocallyCompactSpace Y where
exists_compact_mem_nhds := by
refine hf.surjective.forall.2 fun x ↦ ?_
rcases exists_compact_mem_nhds x with ⟨K, hKc, hKx⟩
exact ⟨f '' K, hKc.image hf.continuous, hf.isOpenMap.image_mem_nhds hKx⟩ | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | IsOpenQuotientMap.weaklyLocallyCompactSpace | null |
exists_compact_superset [WeaklyLocallyCompactSpace X] {K : Set X} (hK : IsCompact K) :
∃ K', IsCompact K' ∧ K ⊆ interior K' := by
choose s hc hmem using fun x : X ↦ exists_compact_mem_nhds x
rcases hK.elim_nhds_subcover _ fun x _ ↦ interior_mem_nhds.2 (hmem x) with ⟨I, -, hIK⟩
refine ⟨⋃ x ∈ I, s x, I.isCompact_biUnion fun _ _ ↦ hc _, hIK.trans ?_⟩
exact iUnion₂_subset fun x hx ↦ interior_mono <| subset_iUnion₂ (s := fun x _ ↦ s x) x hx | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | exists_compact_superset | In a weakly locally compact space,
every compact set is contained in the interior of a compact set. |
disjoint_nhds_cocompact [WeaklyLocallyCompactSpace X] (x : X) :
Disjoint (𝓝 x) (cocompact X) :=
let ⟨_, hc, hx⟩ := exists_compact_mem_nhds x
disjoint_of_disjoint_of_mem disjoint_compl_right hx hc.compl_mem_cocompact | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | disjoint_nhds_cocompact | In a weakly locally compact space,
the filters `𝓝 x` and `cocompact X` are disjoint for all `X`. |
compact_basis_nhds [LocallyCompactSpace X] (x : X) :
(𝓝 x).HasBasis (fun s => s ∈ 𝓝 x ∧ IsCompact s) fun s => s :=
hasBasis_self.2 <| by simpa only [and_comm] using LocallyCompactSpace.local_compact_nhds x | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | compact_basis_nhds | null |
local_compact_nhds [LocallyCompactSpace X] {x : X} {n : Set X} (h : n ∈ 𝓝 x) :
∃ s ∈ 𝓝 x, s ⊆ n ∧ IsCompact s :=
LocallyCompactSpace.local_compact_nhds _ _ h | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | local_compact_nhds | null |
LocallyCompactSpace.of_hasBasis {ι : X → Type*} {p : ∀ x, ι x → Prop}
{s : ∀ x, ι x → Set X} (h : ∀ x, (𝓝 x).HasBasis (p x) (s x))
(hc : ∀ x i, p x i → IsCompact (s x i)) : LocallyCompactSpace X :=
⟨fun x _t ht =>
let ⟨i, hp, ht⟩ := (h x).mem_iff.1 ht
⟨s x i, (h x).mem_of_mem hp, ht, hc x i hp⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | LocallyCompactSpace.of_hasBasis | null |
Prod.locallyCompactSpace (X : Type*) (Y : Type*) [TopologicalSpace X]
[TopologicalSpace Y] [LocallyCompactSpace X] [LocallyCompactSpace Y] :
LocallyCompactSpace (X × Y) :=
have := fun x : X × Y => (compact_basis_nhds x.1).prod_nhds' (compact_basis_nhds x.2)
.of_hasBasis this fun _ _ ⟨⟨_, h₁⟩, _, h₂⟩ => h₁.prod h₂ | instance | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Prod.locallyCompactSpace | null |
Pi.locallyCompactSpace_of_finite [Finite ι] : LocallyCompactSpace (∀ i, X i) :=
⟨fun t n hn => by
rw [nhds_pi, Filter.mem_pi] at hn
obtain ⟨s, -, n', hn', hsub⟩ := hn
choose n'' hn'' hsub' hc using fun i =>
LocallyCompactSpace.local_compact_nhds (t i) (n' i) (hn' i)
refine ⟨(Set.univ : Set ι).pi n'', ?_, subset_trans (fun _ h => ?_) hsub, isCompact_univ_pi hc⟩
· exact (set_pi_mem_nhds_iff (@Set.finite_univ ι _) _).mpr fun i _ => hn'' i
· exact fun i _ => hsub' i (h i trivial)⟩ | instance | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Pi.locallyCompactSpace_of_finite | In general it suffices that all but finitely many of the spaces are compact,
but that's not straightforward to state and use. |
Pi.locallyCompactSpace [∀ i, CompactSpace (X i)] : LocallyCompactSpace (∀ i, X i) :=
⟨fun t n hn => by
rw [nhds_pi, Filter.mem_pi] at hn
obtain ⟨s, hs, n', hn', hsub⟩ := hn
choose n'' hn'' hsub' hc using fun i =>
LocallyCompactSpace.local_compact_nhds (t i) (n' i) (hn' i)
refine ⟨s.pi n'', ?_, subset_trans (fun _ => ?_) hsub, ?_⟩
· exact (set_pi_mem_nhds_iff hs _).mpr fun i _ => hn'' i
· exact forall₂_imp fun i _ hi' => hsub' i hi'
· classical
rw [← Set.univ_pi_ite]
refine isCompact_univ_pi fun i => ?_
by_cases h : i ∈ s
· rw [if_pos h]
exact hc i
· rw [if_neg h]
exact CompactSpace.isCompact_univ⟩ | instance | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Pi.locallyCompactSpace | For spaces that are not Hausdorff. |
Function.locallyCompactSpace_of_finite [Finite ι] [LocallyCompactSpace Y] :
LocallyCompactSpace (ι → Y) :=
Pi.locallyCompactSpace_of_finite | instance | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Function.locallyCompactSpace_of_finite | null |
Function.locallyCompactSpace [LocallyCompactSpace Y] [CompactSpace Y] :
LocallyCompactSpace (ι → Y) :=
Pi.locallyCompactSpace | instance | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Function.locallyCompactSpace | null |
exists_compact_subset [LocallyCompactSpace X] {x : X} {U : Set X} (hU : IsOpen U)
(hx : x ∈ U) : ∃ K : Set X, IsCompact K ∧ x ∈ interior K ∧ K ⊆ U := by
rcases LocallyCompactSpace.local_compact_nhds x U (hU.mem_nhds hx) with ⟨K, h1K, h2K, h3K⟩
exact ⟨K, h3K, mem_interior_iff_mem_nhds.2 h1K, h2K⟩ | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | exists_compact_subset | A reformulation of the definition of locally compact space: In a locally compact space,
every open set containing `x` has a compact subset containing `x` in its interior. |
exists_mem_nhdsSet_isCompact_mapsTo [LocallyCompactPair X Y] {f : X → Y} {K : Set X}
{U : Set Y} (hf : Continuous f) (hK : IsCompact K) (hU : IsOpen U) (hKU : MapsTo f K U) :
∃ L ∈ 𝓝ˢ K, IsCompact L ∧ MapsTo f L U := by
choose! V hxV hVc hVU using fun x (hx : x ∈ K) ↦
exists_mem_nhds_isCompact_mapsTo hf (hU.mem_nhds (hKU hx))
rcases hK.elim_nhds_subcover_nhdsSet hxV with ⟨s, hsK, hKs⟩
exact ⟨_, hKs, s.isCompact_biUnion fun x hx ↦ hVc x (hsK x hx), mapsTo_iUnion₂.2 fun x hx ↦
hVU x (hsK x hx)⟩ | lemma | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | exists_mem_nhdsSet_isCompact_mapsTo | If `f : X → Y` is a continuous map in a locally compact pair of topological spaces,
`K : set X` is a compact set, and `U` is an open neighbourhood of `f '' K`,
then there exists a compact neighbourhood `L` of `K` such that `f` maps `L` to `U`.
This is a generalization of `exists_mem_nhds_isCompact_mapsTo`. |
exists_compact_between [LocallyCompactSpace X] {K U : Set X} (hK : IsCompact K)
(hU : IsOpen U) (h_KU : K ⊆ U) : ∃ L, IsCompact L ∧ K ⊆ interior L ∧ L ⊆ U :=
let ⟨L, hKL, hL, hLU⟩ := exists_mem_nhdsSet_isCompact_mapsTo continuous_id hK hU h_KU
⟨L, hL, subset_interior_iff_mem_nhdsSet.2 hKL, hLU⟩ | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | exists_compact_between | In a locally compact space, for every containment `K ⊆ U` of a compact set `K` in an open
set `U`, there is a compact neighborhood `L` such that `K ⊆ L ⊆ U`: equivalently, there is a
compact `L` such that `K ⊆ interior L` and `L ⊆ U`.
See also `exists_compact_closed_between`, in which one guarantees additionally that `L` is closed
if the space is regular. |
IsOpenQuotientMap.locallyCompactSpace [LocallyCompactSpace X] {f : X → Y}
(hf : IsOpenQuotientMap f) : LocallyCompactSpace Y where
local_compact_nhds := by
refine hf.surjective.forall.2 fun x U hU ↦ ?_
rcases local_compact_nhds (hf.continuous.continuousAt hU) with ⟨K, hKx, hKU, hKc⟩
exact ⟨f '' K, hf.isOpenMap.image_mem_nhds hKx, image_subset_iff.2 hKU, hKc.image hf.continuous⟩ | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | IsOpenQuotientMap.locallyCompactSpace | null |
Topology.IsInducing.locallyCompactSpace [LocallyCompactSpace Y] {f : X → Y}
(hf : IsInducing f) (h : IsLocallyClosed (range f)) : LocallyCompactSpace X := by
rcases h with ⟨U, Z, hU, hZ, hUZ⟩
have (x : X) : (𝓝 x).HasBasis (fun s ↦ (s ∈ 𝓝 (f x) ∧ IsCompact s) ∧ s ⊆ U)
(fun s ↦ f ⁻¹' (s ∩ Z)) := by
have H : U ∈ 𝓝 (f x) := hU.mem_nhds (hUZ.subset <| mem_range_self _).1
rw [hf.nhds_eq_comap, ← comap_nhdsWithin_range, hUZ,
nhdsWithin_inter_of_mem (nhdsWithin_le_nhds H)]
exact (nhdsWithin_hasBasis ((compact_basis_nhds (f x)).restrict_subset H) _).comap _
refine .of_hasBasis this fun x s ⟨⟨_, hs⟩, hsU⟩ ↦ ?_
rw [hf.isCompact_preimage_iff]
exacts [hs.inter_right hZ, hUZ ▸ by gcongr] | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Topology.IsInducing.locallyCompactSpace | If `f` is a topology inducing map with a locally compact codomain and a locally closed range,
then the domain of `f` is a locally compact space. |
protected Topology.IsClosedEmbedding.locallyCompactSpace [LocallyCompactSpace Y] {f : X → Y}
(hf : IsClosedEmbedding f) : LocallyCompactSpace X :=
hf.isInducing.locallyCompactSpace hf.isClosed_range.isLocallyClosed | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Topology.IsClosedEmbedding.locallyCompactSpace | null |
protected Topology.IsOpenEmbedding.locallyCompactSpace [LocallyCompactSpace Y] {f : X → Y}
(hf : IsOpenEmbedding f) : LocallyCompactSpace X :=
hf.isInducing.locallyCompactSpace hf.isOpen_range.isLocallyClosed | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | Topology.IsOpenEmbedding.locallyCompactSpace | null |
protected IsLocallyClosed.locallyCompactSpace [LocallyCompactSpace X] {s : Set X}
(hs : IsLocallyClosed s) : LocallyCompactSpace s :=
IsEmbedding.subtypeVal.locallyCompactSpace <| by rwa [Subtype.range_val] | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | IsLocallyClosed.locallyCompactSpace | null |
protected IsClosed.locallyCompactSpace [LocallyCompactSpace X] {s : Set X}
(hs : IsClosed s) : LocallyCompactSpace s :=
hs.isLocallyClosed.locallyCompactSpace | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | IsClosed.locallyCompactSpace | null |
protected IsOpen.locallyCompactSpace [LocallyCompactSpace X] {s : Set X} (hs : IsOpen s) :
LocallyCompactSpace s :=
hs.isLocallyClosed.locallyCompactSpace | theorem | Topology | [
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyCompact.lean | IsOpen.locallyCompactSpace | null |
finite_nonempty_inter_compact {f : ι → Set X}
(hf : LocallyFinite f) (hs : IsCompact s) : { i | (f i ∩ s).Nonempty }.Finite := by
choose U hxU hUf using hf
rcases hs.elim_nhds_subcover U fun x _ => hxU x with ⟨t, -, hsU⟩
refine (t.finite_toSet.biUnion fun x _ => hUf x).subset ?_
rintro i ⟨x, hx⟩
rcases mem_iUnion₂.1 (hsU hx.2) with ⟨c, hct, hcx⟩
exact mem_biUnion hct ⟨x, hx.1, hcx⟩ | theorem | Topology | [
"Mathlib.Topology.LocallyFinite",
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyFinite.lean | finite_nonempty_inter_compact | If `s` is a compact set in a topological space `X` and `f : ι → Set X` is a locally finite
family of sets, then `f i ∩ s` is nonempty only for a finitely many `i`. |
finite_nonempty_of_compact [CompactSpace X] {f : ι → Set X}
(hf : LocallyFinite f) : { i | (f i).Nonempty }.Finite := by
simpa only [inter_univ] using hf.finite_nonempty_inter_compact isCompact_univ | theorem | Topology | [
"Mathlib.Topology.LocallyFinite",
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyFinite.lean | finite_nonempty_of_compact | If `X` is a compact space, then a locally finite family of sets of `X` can have only finitely
many nonempty elements. |
finite_of_compact [CompactSpace X] {f : ι → Set X}
(hf : LocallyFinite f) (hne : ∀ i, (f i).Nonempty) : (univ : Set ι).Finite := by
simpa only [hne] using hf.finite_nonempty_of_compact | theorem | Topology | [
"Mathlib.Topology.LocallyFinite",
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyFinite.lean | finite_of_compact | If `X` is a compact space, then a locally finite family of nonempty sets of `X` can have only
finitely many elements, `Set.Finite` version. |
noncomputable fintypeOfCompact [CompactSpace X] {f : ι → Set X}
(hf : LocallyFinite f) (hne : ∀ i, (f i).Nonempty) : Fintype ι :=
fintypeOfFiniteUniv (hf.finite_of_compact hne) | def | Topology | [
"Mathlib.Topology.LocallyFinite",
"Mathlib.Topology.Compactness.Compact"
] | Mathlib/Topology/Compactness/LocallyFinite.lean | fintypeOfCompact | If `X` is a compact space, then a locally finite family of nonempty sets of `X` can have only
finitely many elements, `Fintype` version. |
IsCompact.nhdsKer_iff : IsCompact (nhdsKer s) ↔ IsCompact s := by
simp only [isCompact_iff_finite_subcover]
peel with ι U hUo
simp only [(isOpen_iUnion hUo).nhdsKer_subset,
(isOpen_iUnion fun i ↦ isOpen_iUnion fun _ ↦ hUo i).nhdsKer_subset]
@[deprecated (since := "2025-07-09")] alias IsCompact.exterior_iff := IsCompact.nhdsKer_iff
protected alias ⟨IsCompact.of_nhdsKer, IsCompact.nhdsKer⟩ := IsCompact.nhdsKer_iff
@[deprecated (since := "2025-07-09")] alias IsCompact.of_exterior := IsCompact.of_nhdsKer
@[deprecated (since := "2025-07-09")] alias IsCompact.exterior := IsCompact.nhdsKer | theorem | Topology | [
"Mathlib.Tactic.Peel",
"Mathlib.Topology.Compactness.Compact",
"Mathlib.Topology.NhdsKer"
] | Mathlib/Topology/Compactness/NhdsKer.lean | IsCompact.nhdsKer_iff | null |
ParacompactSpace (X : Type v) [TopologicalSpace X] : Prop where
/-- Every open cover of a paracompact space assumes a locally finite refinement. -/
locallyFinite_refinement :
∀ (α : Type v) (s : α → Set X), (∀ a, IsOpen (s a)) → (⋃ a, s a = univ) →
∃ (β : Type v) (t : β → Set X),
(∀ b, IsOpen (t b)) ∧ (⋃ b, t b = univ) ∧ LocallyFinite t ∧ ∀ b, ∃ a, t b ⊆ s a
variable {ι : Type u} {X : Type v} {Y : Type w} [TopologicalSpace X] [TopologicalSpace Y] | class | Topology | [
"Mathlib.Data.Option.Basic",
"Mathlib.Topology.Separation.Regular"
] | Mathlib/Topology/Compactness/Paracompact.lean | ParacompactSpace | A topological space is called paracompact, if every open covering of this space admits a locally
finite refinement. We use the same universe for all types in the definition to avoid creating a
class like `ParacompactSpace.{u v}`. Due to lemma `precise_refinement` below, every open covering
`s : α → Set X` indexed on `α : Type v` has a *precise* locally finite refinement, i.e., a locally
finite refinement `t : α → Set X` indexed on the same type such that each `∀ i, t i ⊆ s i`. |
precise_refinement [ParacompactSpace X] (u : ι → Set X) (uo : ∀ a, IsOpen (u a))
(uc : ⋃ i, u i = univ) : ∃ v : ι → Set X, (∀ a, IsOpen (v a)) ∧ ⋃ i, v i = univ ∧
LocallyFinite v ∧ ∀ a, v a ⊆ u a := by
have := ParacompactSpace.locallyFinite_refinement (range u) (fun r ↦ (r : Set X))
(forall_subtype_range_iff.2 uo) (by rwa [← sUnion_range, Subtype.range_coe])
simp only [exists_subtype_range_iff, iUnion_eq_univ_iff] at this
choose α t hto hXt htf ind hind using this
choose t_inv ht_inv using hXt
choose U hxU hU using htf
refine ⟨fun i ↦ ⋃ (a : α) (_ : ind a = i), t a, ?_, ?_, ?_, ?_⟩
· exact fun a ↦ isOpen_iUnion fun a ↦ isOpen_iUnion fun _ ↦ hto a
· simp only [eq_univ_iff_forall, mem_iUnion]
exact fun x ↦ ⟨ind (t_inv x), _, rfl, ht_inv _⟩
· refine fun x ↦ ⟨U x, hxU x, ((hU x).image ind).subset ?_⟩
simp only [subset_def, mem_iUnion, mem_setOf_eq, Set.Nonempty, mem_inter_iff]
rintro i ⟨y, ⟨a, rfl, hya⟩, hyU⟩
exact mem_image_of_mem _ ⟨y, hya, hyU⟩
· simp only [subset_def, mem_iUnion]
rintro i x ⟨a, rfl, hxa⟩
exact hind _ hxa | theorem | Topology | [
"Mathlib.Data.Option.Basic",
"Mathlib.Topology.Separation.Regular"
] | Mathlib/Topology/Compactness/Paracompact.lean | precise_refinement | Any open cover of a paracompact space has a locally finite *precise* refinement, that is,
one indexed on the same type with each open set contained in the corresponding original one. |
precise_refinement_set [ParacompactSpace X] {s : Set X} (hs : IsClosed s) (u : ι → Set X)
(uo : ∀ i, IsOpen (u i)) (us : s ⊆ ⋃ i, u i) :
∃ v : ι → Set X, (∀ i, IsOpen (v i)) ∧ (s ⊆ ⋃ i, v i) ∧ LocallyFinite v ∧ ∀ i, v i ⊆ u i := by
have uc : (iUnion fun i => Option.elim' sᶜ u i) = univ := by
apply Subset.antisymm (subset_univ _)
· simp_rw [← compl_union_self s, Option.elim', iUnion_option]
apply union_subset_union_right sᶜ us
rcases precise_refinement (Option.elim' sᶜ u) (Option.forall.2 ⟨isOpen_compl_iff.2 hs, uo⟩)
uc with
⟨v, vo, vc, vf, vu⟩
refine ⟨v ∘ some, fun i ↦ vo _, ?_, vf.comp_injective (Option.some_injective _), fun i ↦ vu _⟩
· simp only [iUnion_option, ← compl_subset_iff_union] at vc
exact Subset.trans (subset_compl_comm.1 <| vu Option.none) vc | theorem | Topology | [
"Mathlib.Data.Option.Basic",
"Mathlib.Topology.Separation.Regular"
] | Mathlib/Topology/Compactness/Paracompact.lean | precise_refinement_set | In a paracompact space, every open covering of a closed set admits a locally finite refinement
indexed by the same type. |
Topology.IsClosedEmbedding.paracompactSpace [ParacompactSpace Y] {e : X → Y}
(he : IsClosedEmbedding e) : ParacompactSpace X where
locallyFinite_refinement α s ho hu := by
choose U hUo hU using fun a ↦ he.isOpen_iff.1 (ho a)
simp only [← hU] at hu ⊢
have heU : range e ⊆ ⋃ i, U i := by
simpa only [range_subset_iff, mem_iUnion, iUnion_eq_univ_iff] using hu
rcases precise_refinement_set he.isClosed_range U hUo heU with ⟨V, hVo, heV, hVf, hVU⟩
refine ⟨α, fun a ↦ e ⁻¹' (V a), fun a ↦ (hVo a).preimage he.continuous, ?_,
hVf.preimage_continuous he.continuous, fun a ↦ ⟨a, preimage_mono (hVU a)⟩⟩
simpa only [range_subset_iff, mem_iUnion, iUnion_eq_univ_iff] using heV | theorem | Topology | [
"Mathlib.Data.Option.Basic",
"Mathlib.Topology.Separation.Regular"
] | Mathlib/Topology/Compactness/Paracompact.lean | Topology.IsClosedEmbedding.paracompactSpace | null |
Homeomorph.paracompactSpace_iff (e : X ≃ₜ Y) : ParacompactSpace X ↔ ParacompactSpace Y :=
⟨fun _ ↦ e.symm.isClosedEmbedding.paracompactSpace, fun _ ↦ e.isClosedEmbedding.paracompactSpace⟩ | theorem | Topology | [
"Mathlib.Data.Option.Basic",
"Mathlib.Topology.Separation.Regular"
] | Mathlib/Topology/Compactness/Paracompact.lean | Homeomorph.paracompactSpace_iff | null |
refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set [WeaklyLocallyCompactSpace X]
[SigmaCompactSpace X] [T2Space X] {ι : X → Type u} {p : ∀ x, ι x → Prop} {B : ∀ x, ι x → Set X}
{s : Set X} (hs : IsClosed s) (hB : ∀ x ∈ s, (𝓝 x).HasBasis (p x) (B x)) :
∃ (α : Type v) (c : α → X) (r : ∀ a, ι (c a)),
(∀ a, c a ∈ s ∧ p (c a) (r a)) ∧
(s ⊆ ⋃ a, B (c a) (r a)) ∧ LocallyFinite fun a ↦ B (c a) (r a) := by
classical
set K' : CompactExhaustion X := CompactExhaustion.choice X
set K : CompactExhaustion X := K'.shiftr.shiftr
set Kdiff := fun n ↦ K (n + 1) \ interior (K n)
have hKcov : ∀ x, x ∈ Kdiff (K'.find x + 1) := fun x ↦ by
simpa only [K'.find_shiftr] using
diff_subset_diff_right interior_subset (K'.shiftr.mem_diff_shiftr_find x)
have Kdiffc : ∀ n, IsCompact (Kdiff n ∩ s) :=
fun n ↦ ((K.isCompact _).diff isOpen_interior).inter_right hs
have : ∀ (n) (x : ↑(Kdiff (n + 1) ∩ s)), (K n)ᶜ ∈ 𝓝 (x : X) :=
fun n x ↦ (K.isClosed n).compl_mem_nhds fun hx' ↦ x.2.1.2 <| K.subset_interior_succ _ hx'
choose! r hrp hr using fun n (x : ↑(Kdiff (n + 1) ∩ s)) ↦ (hB x x.2.2).mem_iff.1 (this n x)
have hxr : ∀ (n x) (hx : x ∈ Kdiff (n + 1) ∩ s), B x (r n ⟨x, hx⟩) ∈ 𝓝 x := fun n x hx ↦
(hB x hx.2).mem_of_mem (hrp _ ⟨x, hx⟩)
choose T hT using fun n ↦ (Kdiffc (n + 1)).elim_nhds_subcover' _ (hxr n)
set T' : ∀ n, Set ↑(Kdiff (n + 1) ∩ s) := fun n ↦ T n
refine ⟨Σ n, T' n, fun a ↦ a.2, fun a ↦ r a.1 a.2, ?_, ?_, ?_⟩
· rintro ⟨n, x, hx⟩
exact ⟨x.2.2, hrp _ _⟩
· refine fun x hx ↦ mem_iUnion.2 ?_
rcases mem_iUnion₂.1 (hT _ ⟨hKcov x, hx⟩) with ⟨⟨c, hc⟩, hcT, hcx⟩
exact ⟨⟨_, ⟨c, hc⟩, hcT⟩, hcx⟩
· intro x
refine
⟨interior (K (K'.find x + 3)),
IsOpen.mem_nhds isOpen_interior (K.subset_interior_succ _ (hKcov x).1), ?_⟩
have : (⋃ k ≤ K'.find x + 2, range (Sigma.mk k) : Set (Σ n, T' n)).Finite :=
(finite_le_nat _).biUnion fun k _ ↦ finite_range _
apply this.subset
rintro ⟨k, c, hc⟩
simp only [mem_iUnion, mem_setOf_eq, Subtype.coe_mk]
rintro ⟨x, hxB : x ∈ B c (r k c), hxK⟩
refine ⟨k, ?_, ⟨c, hc⟩, rfl⟩
have := (mem_compl_iff _ _).1 (hr k c hxB)
contrapose! this with hnk
exact K.subset hnk (interior_subset hxK) | theorem | Topology | [
"Mathlib.Data.Option.Basic",
"Mathlib.Topology.Separation.Regular"
] | Mathlib/Topology/Compactness/Paracompact.lean | refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set | The product of a compact space and a paracompact space is a paracompact space. The formalization
is based on https://dantopology.wordpress.com/2009/10/24/compact-x-paracompact-is-paracompact/
with some minor modifications.
This version assumes that `X` in `X × Y` is compact and `Y` is paracompact, see next lemma for the
other case. -/
instance (priority := 200) [CompactSpace X] [ParacompactSpace Y] : ParacompactSpace (X × Y) where
locallyFinite_refinement α s ho hu := by
have : ∀ (x : X) (y : Y), ∃ (a : α) (U : Set X) (V : Set Y),
IsOpen U ∧ IsOpen V ∧ x ∈ U ∧ y ∈ V ∧ U ×ˢ V ⊆ s a := fun x y ↦
(iUnion_eq_univ_iff.1 hu (x, y)).imp fun a ha ↦ isOpen_prod_iff.1 (ho a) x y ha
choose a U V hUo hVo hxU hyV hUV using this
choose T hT using fun y ↦ CompactSpace.elim_nhds_subcover (U · y) fun x ↦
(hUo x y).mem_nhds (hxU x y)
set W : Y → Set Y := fun y ↦ ⋂ x ∈ T y, V x y
have hWo : ∀ y, IsOpen (W y) := fun y ↦ isOpen_biInter_finset fun _ _ ↦ hVo _ _
have hW : ∀ y, y ∈ W y := fun _ ↦ mem_iInter₂.2 fun _ _ ↦ hyV _ _
rcases precise_refinement W hWo (iUnion_eq_univ_iff.2 fun y ↦ ⟨y, hW y⟩)
with ⟨E, hEo, hE, hEf, hEA⟩
refine ⟨Σ y, T y, fun z ↦ U z.2.1 z.1 ×ˢ E z.1, fun _ ↦ (hUo _ _).prod (hEo _),
iUnion_eq_univ_iff.2 fun (x, y) ↦ ?_, fun (x, y) ↦ ?_, fun ⟨y, x, hx⟩ ↦ ?_⟩
· rcases iUnion_eq_univ_iff.1 hE y with ⟨b, hb⟩
rcases iUnion₂_eq_univ_iff.1 (hT b) x with ⟨a, ha, hx⟩
exact ⟨⟨b, a, ha⟩, hx, hb⟩
· rcases hEf y with ⟨t, ht, htf⟩
refine ⟨univ ×ˢ t, prod_mem_nhds univ_mem ht, ?_⟩
refine (htf.biUnion fun y _ ↦ finite_range (Sigma.mk y)).subset ?_
rintro ⟨b, a, ha⟩ ⟨⟨c, d⟩, ⟨-, hd : d ∈ E b⟩, -, hdt : d ∈ t⟩
exact mem_iUnion₂.2 ⟨b, ⟨d, hd, hdt⟩, mem_range_self _⟩
· refine ⟨a x y, (Set.prod_mono Subset.rfl ?_).trans (hUV x y)⟩
exact (hEA _).trans (iInter₂_subset x hx)
instance (priority := 200) [ParacompactSpace X] [CompactSpace Y] : ParacompactSpace (X × Y) :=
(Homeomorph.prodComm X Y).paracompactSpace_iff.2 inferInstance
-- See note [lower instance priority]
/-- A compact space is paracompact. -/
instance (priority := 100) paracompact_of_compact [CompactSpace X] : ParacompactSpace X := by
-- the proof is trivial: we choose a finite subcover using compactness, and use it
refine ⟨fun ι s ho hu ↦ ?_⟩
rcases isCompact_univ.elim_finite_subcover _ ho hu.ge with ⟨T, hT⟩
refine ⟨(T : Set ι), fun t ↦ s t, fun t ↦ ho _, ?_, locallyFinite_of_finite _,
fun t ↦ ⟨t, Subset.rfl⟩⟩
simpa only [iUnion_coe_set, ← univ_subset_iff]
/-- Let `X` be a locally compact sigma compact Hausdorff topological space, let `s` be a closed set
in `X`. Suppose that for each `x ∈ s` the sets `B x : ι x → Set X` with the predicate
`p x : ι x → Prop` form a basis of the filter `𝓝 x`. Then there exists a locally finite covering
`fun i ↦ B (c i) (r i)` of `s` such that all “centers” `c i` belong to `s` and each `r i` satisfies
`p (c i)`.
The notation is inspired by the case `B x r = Metric.ball x r` but the theorem applies to
`nhds_basis_opens` as well. If the covering must be subordinate to some open covering of `s`, then
the user should use a basis obtained by `Filter.HasBasis.restrict_subset` or a similar lemma, see
the proof of `paracompact_of_locallyCompact_sigmaCompact` for an example.
The formalization is based on two [ncatlab](https://ncatlab.org/) proofs:
* [locally compact and sigma compact spaces are paracompact](https://ncatlab.org/nlab/show/locally+compact+and+sigma-compact+spaces+are+paracompact);
* [open cover of smooth manifold admits locally finite refinement by closed balls](https://ncatlab.org/nlab/show/partition+of+unity#ExistenceOnSmoothManifolds).
See also `refinement_of_locallyCompact_sigmaCompact_of_nhds_basis` for a version of this lemma
dealing with a covering of the whole space.
In most cases (namely, if `B c r ∪ B c r'` is again a set of the form `B c r''`) it is possible
to choose `α = X`. This fact is not yet formalized in `mathlib`. |
refinement_of_locallyCompact_sigmaCompact_of_nhds_basis [WeaklyLocallyCompactSpace X]
[SigmaCompactSpace X] [T2Space X] {ι : X → Type u} {p : ∀ x, ι x → Prop} {B : ∀ x, ι x → Set X}
(hB : ∀ x, (𝓝 x).HasBasis (p x) (B x)) :
∃ (α : Type v) (c : α → X) (r : ∀ a, ι (c a)),
(∀ a, p (c a) (r a)) ∧ ⋃ a, B (c a) (r a) = univ ∧ LocallyFinite fun a ↦ B (c a) (r a) :=
let ⟨α, c, r, hp, hU, hfin⟩ :=
refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set isClosed_univ fun x _ ↦ hB x
⟨α, c, r, fun a ↦ (hp a).2, univ_subset_iff.1 hU, hfin⟩ | theorem | Topology | [
"Mathlib.Data.Option.Basic",
"Mathlib.Topology.Separation.Regular"
] | Mathlib/Topology/Compactness/Paracompact.lean | refinement_of_locallyCompact_sigmaCompact_of_nhds_basis | Let `X` be a locally compact sigma compact Hausdorff topological space. Suppose that for each
`x` the sets `B x : ι x → Set X` with the predicate `p x : ι x → Prop` form a basis of the filter
`𝓝 x`. Then there exists a locally finite covering `fun i ↦ B (c i) (r i)` of `X` such that each
`r i` satisfies `p (c i)`.
The notation is inspired by the case `B x r = Metric.ball x r` but the theorem applies to
`nhds_basis_opens` as well. If the covering must be subordinate to some open covering of `s`, then
the user should use a basis obtained by `Filter.HasBasis.restrict_subset` or a similar lemma, see
the proof of `paracompact_of_locallyCompact_sigmaCompact` for an example.
The formalization is based on two [ncatlab](https://ncatlab.org/) proofs:
* [locally compact and sigma compact spaces are paracompact](https://ncatlab.org/nlab/show/locally+compact+and+sigma-compact+spaces+are+paracompact);
* [open cover of smooth manifold admits locally finite refinement by closed balls](https://ncatlab.org/nlab/show/partition+of+unity#ExistenceOnSmoothManifolds).
See also `refinement_of_locallyCompact_sigmaCompact_of_nhds_basis_set` for a version of this lemma
dealing with a covering of a closed set.
In most cases (namely, if `B c r ∪ B c r'` is again a set of the form `B c r''`) it is possible
to choose `α = X`. This fact is not yet formalized in `mathlib`. |
SecondCountableTopology.ofPseudoMetrizableSpaceLindelofSpace [PseudoMetrizableSpace X]
[LindelofSpace X] : SecondCountableTopology X := by
letI : PseudoMetricSpace X := TopologicalSpace.pseudoMetrizableSpacePseudoMetric X
have h_dense (ε) (hpos : 0 < ε) : ∃ s : Set X, s.Countable ∧ ∀ x, ∃ y ∈ s, dist x y ≤ ε := by
let U := fun (z : X) ↦ Metric.ball z ε
obtain ⟨t, hct, huniv⟩ := LindelofSpace.elim_nhds_subcover U
(fun _ ↦ (Metric.isOpen_ball).mem_nhds (Metric.mem_ball_self hpos))
refine ⟨t, hct, fun z ↦ ?_⟩
obtain ⟨y, ht, hzy⟩ : ∃ y ∈ t, z ∈ U y :=
exists_set_mem_of_union_eq_top t (fun i ↦ U i) huniv z
exact ⟨y, ht, (Metric.mem_ball.mp hzy).le⟩
exact Metric.secondCountable_of_almost_dense_set h_dense | instance | Topology | [
"Mathlib.Topology.Metrizable.Basic",
"Mathlib.Topology.Compactness.Lindelof"
] | Mathlib/Topology/Compactness/PseudometrizableLindelof.lean | SecondCountableTopology.ofPseudoMetrizableSpaceLindelofSpace | null |
IsSigmaCompact (s : Set X) : Prop :=
∃ K : ℕ → Set X, (∀ n, IsCompact (K n)) ∧ ⋃ n, K n = s | def | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | IsSigmaCompact | A subset `s ⊆ X` is called **σ-compact** if it is the union of countably many compact sets. |
IsCompact.isSigmaCompact {s : Set X} (hs : IsCompact s) : IsSigmaCompact s :=
⟨fun _ => s, fun _ => hs, iUnion_const _⟩ | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | IsCompact.isSigmaCompact | Compact sets are σ-compact. |
@[simp]
isSigmaCompact_empty : IsSigmaCompact (∅ : Set X) :=
IsCompact.isSigmaCompact isCompact_empty | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_empty | The empty set is σ-compact. |
isSigmaCompact_iUnion_of_isCompact [hι : Countable ι] (s : ι → Set X)
(hcomp : ∀ i, IsCompact (s i)) : IsSigmaCompact (⋃ i, s i) := by
rcases isEmpty_or_nonempty ι
· simp only [iUnion_of_empty, isSigmaCompact_empty]
· -- If ι is non-empty, choose a surjection f : ℕ → ι, this yields a map ℕ → Set X.
obtain ⟨f, hf⟩ := countable_iff_exists_surjective.mp hι
exact ⟨s ∘ f, fun n ↦ hcomp (f n), Function.Surjective.iUnion_comp hf _⟩ | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_iUnion_of_isCompact | Countable unions of compact sets are σ-compact. |
isSigmaCompact_sUnion_of_isCompact {S : Set (Set X)} (hc : Set.Countable S)
(hcomp : ∀ (s : Set X), s ∈ S → IsCompact s) : IsSigmaCompact (⋃₀ S) := by
have : Countable S := countable_coe_iff.mpr hc
rw [sUnion_eq_iUnion]
apply isSigmaCompact_iUnion_of_isCompact _ (fun ⟨s, hs⟩ ↦ hcomp s hs) | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_sUnion_of_isCompact | Countable unions of compact sets are σ-compact. |
isSigmaCompact_iUnion [Countable ι] (s : ι → Set X)
(hcomp : ∀ i, IsSigmaCompact (s i)) : IsSigmaCompact (⋃ i, s i) := by
choose K hcomp hcov using fun i ↦ hcomp i
have := calc
⋃ i, s i
_ = ⋃ i, ⋃ n, (K i n) := by simp_rw [hcov]
_ = ⋃ (i) (n : ℕ), (K.uncurry ⟨i, n⟩) := by rw [Function.uncurry_def]
_ = ⋃ x, K.uncurry x := by rw [← iUnion_prod']
rw [this]
exact isSigmaCompact_iUnion_of_isCompact K.uncurry fun x ↦ (hcomp x.1 x.2) | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_iUnion | Countable unions of σ-compact sets are σ-compact. |
isSigmaCompact_sUnion (S : Set (Set X)) (hc : Set.Countable S)
(hcomp : ∀ s : S, IsSigmaCompact s (X := X)) : IsSigmaCompact (⋃₀ S) := by
have : Countable S := countable_coe_iff.mpr hc
apply sUnion_eq_iUnion.symm ▸ isSigmaCompact_iUnion _ hcomp | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_sUnion | Countable unions of σ-compact sets are σ-compact. |
isSigmaCompact_biUnion {s : Set ι} {S : ι → Set X} (hc : Set.Countable s)
(hcomp : ∀ (i : ι), i ∈ s → IsSigmaCompact (S i)) :
IsSigmaCompact (⋃ (i : ι) (_ : i ∈ s), S i) := by
have : Countable ↑s := countable_coe_iff.mpr hc
rw [biUnion_eq_iUnion]
exact isSigmaCompact_iUnion _ (fun ⟨i', hi'⟩ ↦ hcomp i' hi') | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_biUnion | Countable unions of σ-compact sets are σ-compact. |
IsSigmaCompact.of_isClosed_subset {s t : Set X} (ht : IsSigmaCompact t)
(hs : IsClosed s) (h : s ⊆ t) : IsSigmaCompact s := by
rcases ht with ⟨K, hcompact, hcov⟩
refine ⟨(fun n ↦ s ∩ (K n)), fun n ↦ (hcompact n).inter_left hs, ?_⟩
rw [← inter_iUnion, hcov]
exact inter_eq_left.mpr h | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | IsSigmaCompact.of_isClosed_subset | A closed subset of a σ-compact set is σ-compact. |
IsSigmaCompact.image_of_continuousOn {f : X → Y} {s : Set X} (hs : IsSigmaCompact s)
(hf : ContinuousOn f s) : IsSigmaCompact (f '' s) := by
rcases hs with ⟨K, hcompact, hcov⟩
refine ⟨fun n ↦ f '' K n, ?_, hcov.symm ▸ image_iUnion.symm⟩
exact fun n ↦ (hcompact n).image_of_continuousOn (hf.mono (hcov.symm ▸ subset_iUnion K n)) | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | IsSigmaCompact.image_of_continuousOn | If `s` is σ-compact and `f` is continuous on `s`, `f(s)` is σ-compact. |
IsSigmaCompact.image {f : X → Y} (hf : Continuous f) {s : Set X} (hs : IsSigmaCompact s) :
IsSigmaCompact (f '' s) := hs.image_of_continuousOn hf.continuousOn | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | IsSigmaCompact.image | If `s` is σ-compact and `f` continuous, `f(s)` is σ-compact. |
Topology.IsInducing.isSigmaCompact_iff {f : X → Y} {s : Set X}
(hf : IsInducing f) : IsSigmaCompact s ↔ IsSigmaCompact (f '' s) := by
constructor
· exact fun h ↦ h.image hf.continuous
· rintro ⟨L, hcomp, hcov⟩
refine ⟨fun n ↦ f ⁻¹' (L n) ∩ s, ?_, ?_⟩
· intro n
have : f '' (f ⁻¹' (L n) ∩ s) = L n := by
rw [image_preimage_inter, inter_eq_left.mpr]
exact (subset_iUnion _ n).trans hcov.le
apply hf.isCompact_iff.mpr (this.symm ▸ (hcomp n))
· calc ⋃ n, f ⁻¹' L n ∩ s
_ = f ⁻¹' (⋃ n, L n) ∩ s := by rw [preimage_iUnion, iUnion_inter]
_ = f ⁻¹' (f '' s) ∩ s := by rw [hcov]
_ = s := inter_eq_right.mpr (subset_preimage_image _ _) | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | Topology.IsInducing.isSigmaCompact_iff | If `f : X → Y` is an inducing map, the image `f '' s` of a set `s` is σ-compact
if and only `s` is σ-compact. |
Topology.IsEmbedding.isSigmaCompact_iff {f : X → Y} {s : Set X}
(hf : IsEmbedding f) : IsSigmaCompact s ↔ IsSigmaCompact (f '' s) :=
hf.isInducing.isSigmaCompact_iff | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | Topology.IsEmbedding.isSigmaCompact_iff | If `f : X → Y` is an embedding, the image `f '' s` of a set `s` is σ-compact
if and only `s` is σ-compact. |
Subtype.isSigmaCompact_iff {p : X → Prop} {s : Set { a // p a }} :
IsSigmaCompact s ↔ IsSigmaCompact ((↑) '' s : Set X) :=
IsEmbedding.subtypeVal.isSigmaCompact_iff | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | Subtype.isSigmaCompact_iff | Sets of subtype are σ-compact iff the image under a coercion is. |
SigmaCompactSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- In a σ-compact space, `Set.univ` is a σ-compact set. -/
isSigmaCompact_univ : IsSigmaCompact (univ : Set X) | class | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | SigmaCompactSpace | A σ-compact space is a space that is the union of a countable collection of compact subspaces.
Note that a locally compact separable T₂ space need not be σ-compact.
The sequence can be extracted using `compactCovering`. |
isSigmaCompact_univ_iff : IsSigmaCompact (univ : Set X) ↔ SigmaCompactSpace X :=
⟨fun h => ⟨h⟩, fun h => h.1⟩ | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_univ_iff | A topological space is σ-compact iff `univ` is σ-compact. |
isSigmaCompact_univ [h : SigmaCompactSpace X] : IsSigmaCompact (univ : Set X) :=
isSigmaCompact_univ_iff.mpr h | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_univ | In a σ-compact space, `univ` is σ-compact. |
SigmaCompactSpace_iff_exists_compact_covering :
SigmaCompactSpace X ↔ ∃ K : ℕ → Set X, (∀ n, IsCompact (K n)) ∧ ⋃ n, K n = univ := by
rw [← isSigmaCompact_univ_iff, IsSigmaCompact] | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | SigmaCompactSpace_iff_exists_compact_covering | A topological space is σ-compact iff there exists a countable collection of compact
subspaces that cover the entire space. |
SigmaCompactSpace.exists_compact_covering [h : SigmaCompactSpace X] :
∃ K : ℕ → Set X, (∀ n, IsCompact (K n)) ∧ ⋃ n, K n = univ :=
SigmaCompactSpace_iff_exists_compact_covering.mp h | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | SigmaCompactSpace.exists_compact_covering | null |
isSigmaCompact_range {f : X → Y} (hf : Continuous f) [SigmaCompactSpace X] :
IsSigmaCompact (range f) :=
image_univ ▸ isSigmaCompact_univ.image hf | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_range | If `X` is σ-compact, `im f` is σ-compact. |
isSigmaCompact_iff_isSigmaCompact_univ {s : Set X} :
IsSigmaCompact s ↔ IsSigmaCompact (univ : Set s) := by
rw [Subtype.isSigmaCompact_iff, image_univ, Subtype.range_coe] | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_iff_isSigmaCompact_univ | A subset `s` is σ-compact iff `s` (with the subspace topology) is a σ-compact space. |
isSigmaCompact_iff_sigmaCompactSpace {s : Set X} :
IsSigmaCompact s ↔ SigmaCompactSpace s :=
isSigmaCompact_iff_isSigmaCompact_univ.trans isSigmaCompact_univ_iff | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isSigmaCompact_iff_sigmaCompactSpace | null |
SigmaCompactSpace.of_countable (S : Set (Set X)) (Hc : S.Countable)
(Hcomp : ∀ s ∈ S, IsCompact s) (HU : ⋃₀ S = univ) : SigmaCompactSpace X :=
⟨(exists_seq_cover_iff_countable ⟨_, isCompact_empty⟩).2 ⟨S, Hc, Hcomp, HU⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | SigmaCompactSpace.of_countable | null |
compactCovering : ℕ → Set X :=
Accumulate exists_compact_covering.choose | def | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | compactCovering | A choice of compact covering for a `σ`-compact space, chosen to be monotone. |
isCompact_compactCovering (n : ℕ) : IsCompact (compactCovering X n) :=
isCompact_accumulate (Classical.choose_spec SigmaCompactSpace.exists_compact_covering).1 n | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isCompact_compactCovering | null |
iUnion_compactCovering : ⋃ n, compactCovering X n = univ := by
rw [compactCovering, iUnion_accumulate]
exact (Classical.choose_spec SigmaCompactSpace.exists_compact_covering).2 | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | iUnion_compactCovering | null |
iUnion_closure_compactCovering : ⋃ n, closure (compactCovering X n) = univ :=
eq_top_mono (iUnion_mono fun _ ↦ subset_closure) (iUnion_compactCovering X)
@[mono, gcongr] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | iUnion_closure_compactCovering | null |
compactCovering_subset ⦃m n : ℕ⦄ (h : m ≤ n) : compactCovering X m ⊆ compactCovering X n :=
monotone_accumulate h
variable {X} | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | compactCovering_subset | null |
exists_mem_compactCovering (x : X) : ∃ n, x ∈ compactCovering X n :=
iUnion_eq_univ_iff.mp (iUnion_compactCovering X) x | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | exists_mem_compactCovering | null |
protected Topology.IsClosedEmbedding.sigmaCompactSpace {e : Y → X}
(he : IsClosedEmbedding e) : SigmaCompactSpace Y :=
⟨⟨fun n => e ⁻¹' compactCovering X n, fun _ =>
he.isCompact_preimage (isCompact_compactCovering _ _), by
rw [← preimage_iUnion, iUnion_compactCovering, preimage_univ]⟩⟩ | lemma | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | Topology.IsClosedEmbedding.sigmaCompactSpace | null |
IsClosed.sigmaCompactSpace {s : Set X} (hs : IsClosed s) : SigmaCompactSpace s :=
hs.isClosedEmbedding_subtypeVal.sigmaCompactSpace | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | IsClosed.sigmaCompactSpace | null |
protected LocallyFinite.countable_univ {f : ι → Set X} (hf : LocallyFinite f)
(hne : ∀ i, (f i).Nonempty) : (univ : Set ι).Countable := by
have := fun n => hf.finite_nonempty_inter_compact (isCompact_compactCovering X n)
refine (countable_iUnion fun n => (this n).countable).mono fun i _ => ?_
rcases hne i with ⟨x, hx⟩
rcases iUnion_eq_univ_iff.1 (iUnion_compactCovering X) x with ⟨n, hn⟩
exact mem_iUnion.2 ⟨n, x, hx, hn⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | LocallyFinite.countable_univ | If `X` is a `σ`-compact space, then a locally finite family of nonempty sets of `X` can have
only countably many elements, `Set.Countable` version. |
protected noncomputable LocallyFinite.encodable {ι : Type*} {f : ι → Set X}
(hf : LocallyFinite f) (hne : ∀ i, (f i).Nonempty) : Encodable ι :=
@Encodable.ofEquiv _ _ (hf.countable_univ hne).toEncodable (Equiv.Set.univ _).symm | def | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | LocallyFinite.encodable | If `f : ι → Set X` is a locally finite covering of a σ-compact topological space by nonempty
sets, then the index type `ι` is encodable. |
countable_cover_nhdsWithin_of_sigmaCompact {f : X → Set X} {s : Set X} (hs : IsClosed s)
(hf : ∀ x ∈ s, f x ∈ 𝓝[s] x) : ∃ t ⊆ s, t.Countable ∧ s ⊆ ⋃ x ∈ t, f x := by
simp only [nhdsWithin, mem_inf_principal] at hf
choose t ht hsub using fun n =>
((isCompact_compactCovering X n).inter_right hs).elim_nhds_subcover _ fun x hx => hf x hx.right
refine
⟨⋃ n, (t n : Set X), iUnion_subset fun n x hx => (ht n x hx).2,
countable_iUnion fun n => (t n).countable_toSet, fun x hx => mem_iUnion₂.2 ?_⟩
rcases exists_mem_compactCovering x with ⟨n, hn⟩
rcases mem_iUnion₂.1 (hsub n ⟨hn, hx⟩) with ⟨y, hyt : y ∈ t n, hyf : x ∈ s → x ∈ f y⟩
exact ⟨y, mem_iUnion.2 ⟨n, hyt⟩, hyf hx⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | countable_cover_nhdsWithin_of_sigmaCompact | In a topological space with sigma compact topology, if `f` is a function that sends each point
`x` of a closed set `s` to a neighborhood of `x` within `s`, then for some countable set `t ⊆ s`,
the neighborhoods `f x`, `x ∈ t`, cover the whole set `s`. |
countable_cover_nhds_of_sigmaCompact {f : X → Set X} (hf : ∀ x, f x ∈ 𝓝 x) :
∃ s : Set X, s.Countable ∧ ⋃ x ∈ s, f x = univ := by
simp only [← nhdsWithin_univ] at hf
rcases countable_cover_nhdsWithin_of_sigmaCompact isClosed_univ fun x _ => hf x with
⟨s, -, hsc, hsU⟩
exact ⟨s, hsc, univ_subset_iff.1 hsU⟩ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | countable_cover_nhds_of_sigmaCompact | In a topological space with sigma compact topology, if `f` is a function that sends each
point `x` to a neighborhood of `x`, then for some countable set `s`, the neighborhoods `f x`,
`x ∈ s`, cover the whole space. |
CompactExhaustion (X : Type*) [TopologicalSpace X] where
/-- The sequence of compact sets that form a compact exhaustion. -/
toFun : ℕ → Set X
/-- The sets in the compact exhaustion are in fact compact. -/
isCompact' : ∀ n, IsCompact (toFun n)
/-- The sets in the compact exhaustion form a sequence:
each set is contained in the interior of the next. -/
subset_interior_succ' : ∀ n, toFun n ⊆ interior (toFun (n + 1))
/-- The union of all sets in a compact exhaustion equals the entire space. -/
iUnion_eq' : ⋃ n, toFun n = univ | structure | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | CompactExhaustion | An [exhaustion by compact sets](https://en.wikipedia.org/wiki/Exhaustion_by_compact_sets) of a
topological space is a sequence of compact sets `K n` such that `K n ⊆ interior (K (n + 1))` and
`⋃ n, K n = univ`.
If `X` is a locally compact sigma compact space, then `CompactExhaustion.choice X` provides
a choice of an exhaustion by compact sets. This choice is also available as
`(default : CompactExhaustion X)`. |
@[simp]
toFun_eq_coe : K.toFun = K := rfl | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | toFun_eq_coe | null |
protected isCompact (n : ℕ) : IsCompact (K n) :=
K.isCompact' n | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | isCompact | null |
subset_interior_succ (n : ℕ) : K n ⊆ interior (K (n + 1)) :=
K.subset_interior_succ' n
@[mono] | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | subset_interior_succ | null |
protected subset ⦃m n : ℕ⦄ (h : m ≤ n) : K m ⊆ K n :=
OrderHomClass.mono K h | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | subset | null |
subset_succ (n : ℕ) : K n ⊆ K (n + 1) := K.subset n.le_succ | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | subset_succ | null |
subset_interior ⦃m n : ℕ⦄ (h : m < n) : K m ⊆ interior (K n) :=
Subset.trans (K.subset_interior_succ m) <| interior_mono <| K.subset h | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | subset_interior | null |
iUnion_eq : ⋃ n, K n = univ :=
K.iUnion_eq' | theorem | Topology | [
"Mathlib.Topology.Bases",
"Mathlib.Topology.Compactness.LocallyCompact",
"Mathlib.Topology.Compactness.LocallyFinite"
] | Mathlib/Topology/Compactness/SigmaCompact.lean | iUnion_eq | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.