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... | 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
... |
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) wi... | 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.continuou... | 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.co... | 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.isCompac... | 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₁.p... | 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... | 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'', ?_, s... | 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 ... | 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 ... |
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.... | 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
ha... | 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 me... | 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 :=... | 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... | 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 `α... |
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_... | 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.... | 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... | 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)),... | 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 t... |
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 (... | 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)`.
Th... |
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 ≤ ε :=... | 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... | 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]
... | 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 ▸ su... | 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... | 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 wit... | 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_su... | 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... | 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 e... |
@[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.