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 ⌀ |
|---|---|---|---|---|---|---|
noncomputable instNonUnitalNormedRing [NonUnitalNormedRing β] :
NonUnitalNormedRing C₀(α, β) :=
{ instNonUnitalSeminormedRing, instNormedAddCommGroup with } | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instNonUnitalNormedRing | null |
noncomputable instNonUnitalSeminormedCommRing [NonUnitalSeminormedCommRing β] :
NonUnitalSeminormedCommRing C₀(α, β) :=
{ instNonUnitalSeminormedRing, instNonUnitalCommRing with } | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instNonUnitalSeminormedCommRing | null |
noncomputable instNonUnitalNormedCommRing [NonUnitalNormedCommRing β] :
NonUnitalNormedCommRing C₀(α, β) :=
{ instNonUnitalNormedRing, instNonUnitalCommRing with } | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instNonUnitalNormedCommRing | null |
instStar : Star C₀(α, β) where
star f :=
{ toFun := fun x => star (f x)
continuous_toFun := (map_continuous f).star
zero_at_infty' := by
simpa only [star_zero] using (continuous_star.tendsto (0 : β)).comp (zero_at_infty f) }
@[simp] | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instStar | null |
coe_star (f : C₀(α, β)) : ⇑(star f) = star (⇑f) :=
rfl | theorem | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | coe_star | null |
star_apply (f : C₀(α, β)) (x : α) : (star f) x = star (f x) :=
rfl | theorem | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | star_apply | null |
instStarAddMonoid [ContinuousAdd β] : StarAddMonoid C₀(α, β) where
star_involutive f := ext fun x => star_star (f x)
star_add f g := ext fun x => star_add (f x) (g x) | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instStarAddMonoid | null |
instNormedStarGroup : NormedStarGroup C₀(α, β) where
norm_star_le f := (norm_star f.toBCF :).le | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instNormedStarGroup | null |
instStarModule : StarModule 𝕜 C₀(α, β) where
star_smul k f := ext fun x => star_smul k (f x) | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instStarModule | null |
instStarRing : StarRing C₀(α, β) :=
{ ZeroAtInftyContinuousMap.instStarAddMonoid with
star_mul := fun f g => ext fun x => star_mul (f x) (g x) } | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instStarRing | null |
instCStarRing [NonUnitalNormedRing β] [StarRing β] [CStarRing β] : CStarRing C₀(α, β) where
norm_mul_self_le f := CStarRing.norm_mul_self_le (x := f.toBCF) | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | instCStarRing | null |
comp (f : C₀(γ, δ)) (g : β →co γ) : C₀(β, δ) where
toContinuousMap := (f : C(γ, δ)).comp g
zero_at_infty' := (zero_at_infty f).comp (cocompact_tendsto g)
@[simp] | def | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | comp | Composition of a continuous function vanishing at infinity with a cocompact map yields another
continuous function vanishing at infinity. |
coe_comp_to_continuous_fun (f : C₀(γ, δ)) (g : β →co γ) : ((f.comp g) : β → δ) = f ∘ g :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | coe_comp_to_continuous_fun | null |
comp_id (f : C₀(γ, δ)) : f.comp (CocompactMap.id γ) = f :=
ext fun _ => rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | comp_id | null |
comp_assoc (f : C₀(γ, δ)) (g : β →co γ) (h : α →co β) :
(f.comp g).comp h = f.comp (g.comp h) :=
rfl
@[simp] | theorem | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | comp_assoc | null |
zero_comp (g : β →co γ) : (0 : C₀(γ, δ)).comp g = 0 :=
rfl | theorem | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | zero_comp | null |
compAddMonoidHom [AddMonoid δ] [ContinuousAdd δ] (g : β →co γ) : C₀(γ, δ) →+ C₀(β, δ) where
toFun f := f.comp g
map_zero' := zero_comp g
map_add' _ _ := rfl | def | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | compAddMonoidHom | Composition as an additive monoid homomorphism. |
compMulHom [MulZeroClass δ] [ContinuousMul δ] (g : β →co γ) : C₀(γ, δ) →ₙ* C₀(β, δ) where
toFun f := f.comp g
map_mul' _ _ := rfl | def | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | compMulHom | Composition as a semigroup homomorphism. |
compLinearMap [AddCommMonoid δ] [ContinuousAdd δ] {R : Type*} [Semiring R] [Module R δ]
[ContinuousConstSMul R δ] (g : β →co γ) : C₀(γ, δ) →ₗ[R] C₀(β, δ) where
toFun f := f.comp g
map_add' _ _ := rfl
map_smul' _ _ := rfl | def | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | compLinearMap | Composition as a linear map. |
compNonUnitalAlgHom {R : Type*} [Semiring R] [NonUnitalNonAssocSemiring δ]
[IsTopologicalSemiring δ] [Module R δ] [ContinuousConstSMul R δ] (g : β →co γ) :
C₀(γ, δ) →ₙₐ[R] C₀(β, δ) where
toFun f := f.comp g
map_smul' _ _ := rfl
map_zero' := rfl
map_add' _ _ := rfl
map_mul' _ _ := rfl | def | Topology | [
"Mathlib.Topology.ContinuousMap.Bounded.Star",
"Mathlib.Topology.ContinuousMap.CocompactMap"
] | Mathlib/Topology/ContinuousMap/ZeroAtInfty.lean | compNonUnitalAlgHom | Composition as a non-unital algebra homomorphism. |
TopologicalSpace (X : Type u) where
/-- A predicate saying that a set is an open set. Use `IsOpen` in the root namespace instead. -/
protected IsOpen : Set X → Prop
/-- The set representing the whole space is an open set.
Use `isOpen_univ` in the root namespace instead. -/
protected isOpen_univ : IsOpen univ
/-- The intersection of two open sets is an open set. Use `IsOpen.inter` instead. -/
protected isOpen_inter : ∀ s t, IsOpen s → IsOpen t → IsOpen (s ∩ t)
/-- The union of a family of open sets is an open set.
Use `isOpen_sUnion` in the root namespace instead. -/
protected isOpen_sUnion : ∀ s, (∀ t ∈ s, IsOpen t) → IsOpen (⋃₀ s)
variable {X : Type u} {Y : Type v}
/-! ### Predicates on sets -/ | class | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | TopologicalSpace | A topology on `X`. |
IsOpen : Set X → Prop := TopologicalSpace.IsOpen
@[simp] theorem isOpen_univ : IsOpen (univ : Set X) := TopologicalSpace.isOpen_univ | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsOpen | `IsOpen s` means that `s` is open in the ambient topological space on `X` |
IsOpen.inter (hs : IsOpen s) (ht : IsOpen t) : IsOpen (s ∩ t) :=
TopologicalSpace.isOpen_inter s t hs ht | theorem | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsOpen.inter | null |
isOpen_sUnion {s : Set (Set X)} (h : ∀ t ∈ s, IsOpen t) : IsOpen (⋃₀ s) :=
TopologicalSpace.isOpen_sUnion s h | theorem | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | isOpen_sUnion | null |
IsClosed (s : Set X) : Prop where
/-- The complement of a closed set is an open set. -/
isOpen_compl : IsOpen sᶜ | class | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsClosed | A set is closed if its complement is open |
IsClopen (s : Set X) : Prop :=
IsClosed s ∧ IsOpen s | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsClopen | A set is clopen if it is both closed and open. |
IsLocallyClosed (s : Set X) : Prop := ∃ (U Z : Set X), IsOpen U ∧ IsClosed Z ∧ s = U ∩ Z | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsLocallyClosed | A set is locally closed if it is the intersection of some open set and some closed set.
Also see `isLocallyClosed_tfae` and other lemmas in `Mathlib/Topology/LocallyClosed.lean`. |
interior (s : Set X) : Set X :=
⋃₀ { t | IsOpen t ∧ t ⊆ s } | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | interior | The interior of a set `s` is the largest open subset of `s`. |
closure (s : Set X) : Set X :=
⋂₀ { t | IsClosed t ∧ s ⊆ t } | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | closure | The closure of `s` is the smallest closed set containing `s`. |
frontier (s : Set X) : Set X :=
closure s \ interior s | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | frontier | The frontier of a set is the set of points between the closure and interior. |
coborder (s : Set X) : Set X :=
(closure s \ s)ᶜ | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | coborder | The coborder is defined as the complement of `closure s \ s`,
or the union of `s` and the complement of `∂(s)`.
This is the largest set in which `s` is closed, and `s` is locally closed if and only if
`coborder s` is open.
This is unnamed in the literature, and this name is due to the fact that `coborder s = (border sᶜ)ᶜ`
where `border s = s \ interior s` is the border in the sense of Hausdorff. |
Dense (s : Set X) : Prop :=
∀ x, x ∈ closure s | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | Dense | A set is dense in a topological space if every point belongs to its closure. |
DenseRange {α : Type*} (f : α → X) := Dense (range f) | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | DenseRange | `f : α → X` has dense range if its range (image) is a dense subset of `X`. |
@[fun_prop]
Continuous (f : X → Y) : Prop where
/-- The preimage of an open set under a continuous function is an open set. Use `IsOpen.preimage`
instead. -/
isOpen_preimage : ∀ s, IsOpen s → IsOpen (f ⁻¹' s) | structure | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | Continuous | A function between topological spaces is continuous if the preimage
of every open set is open. Registered as a structure to make sure it is not unfolded by Lean. |
IsOpenMap (f : X → Y) : Prop := ∀ U : Set X, IsOpen U → IsOpen (f '' U) | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsOpenMap | A map `f : X → Y` is said to be an *open map*,
if the image of any open `U : Set X` is open in `Y`. |
IsClosedMap (f : X → Y) : Prop := ∀ U : Set X, IsClosed U → IsClosed (f '' U) | def | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsClosedMap | A map `f : X → Y` is said to be a *closed map*,
if the image of any closed `U : Set X` is closed in `Y`. |
@[mk_iff]
IsOpenQuotientMap (f : X → Y) : Prop where
/-- An open quotient map is surjective. -/
surjective : Function.Surjective f
/-- An open quotient map is continuous. -/
continuous : Continuous f
/-- An open quotient map is an open map. -/
isOpenMap : IsOpenMap f | structure | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | IsOpenQuotientMap | An open quotient map is an open map `f : X → Y` which is both an open map and a quotient map.
Equivalently, it is a surjective continuous open map.
We use the latter characterization as a definition.
Many important quotient maps are open quotient maps, including
- the quotient map from a topological space to its quotient by the action of a group;
- the quotient map from a topological group to its quotient by a normal subgroup;
- the quotient map from a topological space to its separation quotient.
Contrary to general quotient maps,
the category of open quotient maps is closed under `Prod.map`. |
BaireSpace (X : Type*) [TopologicalSpace X] : Prop where
baire_property : ∀ f : ℕ → Set X, (∀ n, IsOpen (f n)) → (∀ n, Dense (f n)) → Dense (⋂ n, f n) | class | Topology | [
"Mathlib.Order.SetNotation",
"Mathlib.Tactic.Continuity",
"Mathlib.Tactic.FunProp",
"Mathlib.Tactic.MkIffOfInductiveProp",
"Mathlib.Tactic.ToAdditive",
"Mathlib.Util.AssertExists"
] | Mathlib/Topology/Defs/Basic.lean | BaireSpace | Notation for `IsOpen` with respect to a non-standard topology. -/
scoped[Topology] notation (name := IsOpen_of) "IsOpen[" t "]" => @IsOpen _ t
/-- Notation for `IsClosed` with respect to a non-standard topology. -/
scoped[Topology] notation (name := IsClosed_of) "IsClosed[" t "]" => @IsClosed _ t
/-- Notation for `closure` with respect to a non-standard topology. -/
scoped[Topology] notation (name := closure_of) "closure[" t "]" => @closure _ t
/-- Notation for `Continuous` with respect to a non-standard topologies. -/
scoped[Topology] notation (name := Continuous_of) "Continuous[" t₁ ", " t₂ "]" =>
@Continuous _ _ t₁ t₂
/-- The property `BaireSpace α` means that the topological space `α` has the Baire property:
any countable intersection of open dense subsets is dense.
Formulated here when the source space is ℕ.
Use `dense_iInter_of_isOpen` which works for any countable index type instead. |
nhdsWithin (x : X) (s : Set X) : Filter X :=
𝓝 x ⊓ 𝓟 s
@[inherit_doc]
scoped[Topology] notation "𝓝[" s "] " x:100 => nhdsWithin x s | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | nhdsWithin | A set is called a neighborhood of `x` if it contains an open set around `x`. The set of all
neighborhoods of `x` forms a filter, the neighborhood filter at `x`, is here defined as the
infimum over the principal filters of all open sets containing `x`. -/
irreducible_def nhds (x : X) : Filter X :=
⨅ s ∈ { s : Set X | x ∈ s ∧ IsOpen s }, 𝓟 s
@[inherit_doc]
scoped[Topology] notation "𝓝" => nhds
/-- The "neighborhood within" filter. Elements of `𝓝[s] x` are sets containing the
intersection of `s` and a neighborhood of `x`. |
nhdsSet (s : Set X) : Filter X :=
sSup (nhds '' s)
@[inherit_doc] scoped[Topology] notation "𝓝ˢ" => nhdsSet | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | nhdsSet | Notation for the filter of punctured neighborhoods of a point. -/
scoped[Topology] notation3 (name := nhdsNE) "𝓝[≠] " x:100 =>
nhdsWithin x (@singleton _ (Set _) Set.instSingletonSet x)ᶜ
/-- Notation for the filter of right neighborhoods of a point. -/
scoped[Topology] notation3 (name := nhdsGE) "𝓝[≥] " x:100 => nhdsWithin x (Set.Ici x)
/-- Notation for the filter of left neighborhoods of a point. -/
scoped[Topology] notation3 (name := nhdsLE) "𝓝[≤] " x:100 => nhdsWithin x (Set.Iic x)
/-- Notation for the filter of punctured right neighborhoods of a point. -/
scoped[Topology] notation3 (name := nhdsGT) "𝓝[>] " x:100 => nhdsWithin x (Set.Ioi x)
/-- Notation for the filter of punctured left neighborhoods of a point. -/
scoped[Topology] notation3 (name := nhdsLT) "𝓝[<] " x:100 => nhdsWithin x (Set.Iio x)
/-- The filter of neighborhoods of a set in a topological space. |
nhdsKer (s : Set X) : Set X := (𝓝ˢ s).ker
@[deprecated (since := "2025-07-09")] alias exterior := nhdsKer | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | nhdsKer | The *neighborhoods kernel* of a set is the intersection of all its neighborhoods. In an
Alexandrov-discrete space, this is the smallest neighborhood of the set. |
@[fun_prop]
ContinuousAt (f : X → Y) (x : X) :=
Tendsto f (𝓝 x) (𝓝 (f x)) | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | ContinuousAt | A function between topological spaces is continuous at a point `x₀`
if `f x` tends to `f x₀` when `x` tends to `x₀`. |
@[fun_prop]
ContinuousWithinAt (f : X → Y) (s : Set X) (x : X) : Prop :=
Tendsto f (𝓝[s] x) (𝓝 (f x)) | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | ContinuousWithinAt | A function between topological spaces is continuous at a point `x₀` within a subset `s`
if `f x` tends to `f x₀` when `x` tends to `x₀` while staying within `s`. |
@[fun_prop]
ContinuousOn (f : X → Y) (s : Set X) : Prop :=
∀ x ∈ s, ContinuousWithinAt f s x | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | ContinuousOn | A function between topological spaces is continuous on a subset `s`
when it's continuous at every point of `s` within `s`. |
Specializes (x y : X) : Prop := 𝓝 x ≤ 𝓝 y
@[inherit_doc]
infixl:300 " ⤳ " => Specializes | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | Specializes | `x` specializes to `y` (notation: `x ⤳ y`) if either of the following equivalent properties
hold:
* `𝓝 x ≤ 𝓝 y`; this property is used as the definition;
* `pure x ≤ 𝓝 y`; in other words, any neighbourhood of `y` contains `x`;
* `y ∈ closure {x}`;
* `closure {y} ⊆ closure {x}`;
* for any closed set `s` we have `x ∈ s → y ∈ s`;
* for any open set `s` we have `y ∈ s → x ∈ s`;
* `y` is a cluster point of the filter `pure x = 𝓟 {x}`.
This relation defines a `Preorder` on `X`. If `X` is a T₀ space, then this preorder is a partial
order. If `X` is a T₁ space, then this partial order is trivial : `x ⤳ y ↔ x = y`. |
Inseparable (x y : X) : Prop :=
𝓝 x = 𝓝 y
variable (X) | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | Inseparable | Two points `x` and `y` in a topological space are `Inseparable` if any of the following
equivalent properties hold:
- `𝓝 x = 𝓝 y`; we use this property as the definition;
- for any open set `s`, `x ∈ s ↔ y ∈ s`, see `inseparable_iff_forall_isOpen`;
- for any closed set `s`, `x ∈ s ↔ y ∈ s`, see `inseparable_iff_forall_isClosed`;
- `x ∈ closure {y}` and `y ∈ closure {x}`, see `inseparable_iff_mem_closure`;
- `closure {x} = closure {y}`, see `inseparable_iff_closure_eq`. |
specializationPreorder : Preorder X :=
{ Preorder.lift (OrderDual.toDual ∘ 𝓝) with
le := fun x y => y ⤳ x
lt := fun x y => y ⤳ x ∧ ¬x ⤳ y } | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | specializationPreorder | Specialization forms a preorder on the topological space. |
inseparableSetoid : Setoid X := { Setoid.comap 𝓝 ⊥ with r := Inseparable } | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | inseparableSetoid | A `setoid` version of `Inseparable`, used to define the `SeparationQuotient`. |
SeparationQuotient := Quotient (inseparableSetoid X)
variable {X} | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | SeparationQuotient | The quotient of a topological space by its `inseparableSetoid`.
This quotient is guaranteed to be a T₀ space. |
noncomputable lim [Nonempty X] (f : Filter X) : X :=
Classical.epsilon fun x => f ≤ 𝓝 x | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | lim | If `f` is a filter, then `Filter.lim f` is a limit of the filter, if it exists. |
noncomputable limUnder {α : Type*} [Nonempty X] (f : Filter α) (g : α → X) : X :=
lim (f.map g) | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | limUnder | If `f` is a filter in `α` and `g : α → X` is a function, then `limUnder f g` is a limit of `g`
at `f`, if it exists. |
ClusterPt (x : X) (F : Filter X) : Prop :=
NeBot (𝓝 x ⊓ F) | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | ClusterPt | A point `x` is a cluster point of a filter `F` if `𝓝 x ⊓ F ≠ ⊥`.
Also known as an accumulation point or a limit point, but beware that terminology varies.
This is *not* the same as asking `𝓝[≠] x ⊓ F ≠ ⊥`, which is called `AccPt` in Mathlib.
See `mem_closure_iff_clusterPt` in particular. |
MapClusterPt {ι : Type*} (x : X) (F : Filter ι) (u : ι → X) : Prop :=
ClusterPt x (map u F) | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | MapClusterPt | A point `x` is a cluster point of a sequence `u` along a filter `F` if it is a cluster point
of `map u F`. |
AccPt (x : X) (F : Filter X) : Prop :=
NeBot (𝓝[≠] x ⊓ F) | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | AccPt | A point `x` is an accumulation point of a filter `F` if `𝓝[≠] x ⊓ F ≠ ⊥`.
See also `ClusterPt`. |
IsCompact (s : Set X) :=
∀ ⦃f⦄ [NeBot f], f ≤ 𝓟 s → ∃ x ∈ s, ClusterPt x f
variable (X) in | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | IsCompact | A set `s` is compact if for every nontrivial filter `f` that contains `s`,
there exists `a ∈ s` such that every set of `f` meets every neighborhood of `a`. |
CompactSpace : Prop where
/-- In a compact space, `Set.univ` is a compact set. -/
isCompact_univ : IsCompact (Set.univ : Set X)
variable (X) in | class | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | CompactSpace | Type class for compact spaces. Separation is sometimes included in the definition, especially
in the French literature, but we do not include it here. |
NoncompactSpace : Prop where
/-- In a noncompact space, `Set.univ` is not a compact set. -/
noncompact_univ : ¬IsCompact (Set.univ : Set X) | class | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | NoncompactSpace | `X` is a noncompact topological space if it is not a compact space. |
WeaklyLocallyCompactSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- Every point of a weakly locally compact space admits a compact neighborhood. -/
exists_compact_mem_nhds (x : X) : ∃ s, IsCompact s ∧ s ∈ 𝓝 x
export WeaklyLocallyCompactSpace (exists_compact_mem_nhds) | class | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | WeaklyLocallyCompactSpace | We say that a topological space is a *weakly locally compact space*,
if each point of this space admits a compact neighborhood. |
LocallyCompactSpace (X : Type*) [TopologicalSpace X] : Prop where
/-- In a locally compact space,
every neighbourhood of every point contains a compact neighbourhood of that same point. -/
local_compact_nhds : ∀ (x : X), ∀ n ∈ 𝓝 x, ∃ s ∈ 𝓝 x, s ⊆ n ∧ IsCompact s | class | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | LocallyCompactSpace | There are various definitions of "locally compact space" in the literature,
which agree for Hausdorff spaces but not in general.
This one is the precise condition on X needed
for the evaluation map `C(X, Y) × X → Y` to be continuous for all `Y`
when `C(X, Y)` is given the compact-open topology.
See also `WeaklyLocallyCompactSpace`, a typeclass that only assumes
that each point has a compact neighborhood. |
LocallyCompactPair (X Y : Type*) [TopologicalSpace X] [TopologicalSpace Y] : Prop where
/-- If `f : X → Y` is a continuous map in a locally compact pair of topological spaces
and `s : Set Y` is a neighbourhood of `f x`, `x : X`,
then there exists a compact neighbourhood `K` of `x` such that `f` maps `K` to `s`. -/
exists_mem_nhds_isCompact_mapsTo : ∀ {f : X → Y} {x : X} {s : Set Y},
Continuous f → s ∈ 𝓝 (f x) → ∃ K ∈ 𝓝 x, IsCompact K ∧ Set.MapsTo f K s
export LocallyCompactPair (exists_mem_nhds_isCompact_mapsTo)
variable (X) in | class | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | LocallyCompactPair | We say that `X` and `Y` are a locally compact pair of topological spaces,
if for any continuous map `f : X → Y`, a point `x : X`, and a neighbourhood `s ∈ 𝓝 (f x)`,
there exists a compact neighbourhood `K ∈ 𝓝 x` such that `f` maps `K` to `s`.
This is a technical assumption that appears in several theorems,
most notably in `ContinuousMap.continuous_comp'` and `ContinuousMap.continuous_eval`.
It is satisfied in two cases:
- if `X` is a locally compact topological space, for obvious reasons;
- if `X` is a weakly locally compact topological space and `Y` is an R₁ space;
this fact is a simple generalization of the theorem
saying that a weakly locally compact R₁ topological space is locally compact. |
Filter.cocompact : Filter X :=
⨅ (s : Set X) (_ : IsCompact s), 𝓟 sᶜ
variable (X) in | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | Filter.cocompact | `Filter.cocompact` is the filter generated by complements to compact sets. |
Filter.coclosedCompact : Filter X :=
⨅ (s : Set X) (_ : IsClosed s) (_ : IsCompact s), 𝓟 sᶜ | def | Topology | [
"Mathlib.Topology.Defs.Basic",
"Mathlib.Data.Setoid.Basic",
"Mathlib.Order.Filter.Defs",
"Mathlib.Tactic.IrreducibleDef"
] | Mathlib/Topology/Defs/Filter.lean | Filter.coclosedCompact | `Filter.coclosedCompact` is the filter generated by complements to closed compact sets.
In a Hausdorff space, this is the same as `Filter.cocompact`. |
induced (f : X → Y) (t : TopologicalSpace Y) : TopologicalSpace X where
IsOpen s := ∃ t, IsOpen t ∧ f ⁻¹' t = s
isOpen_univ := ⟨univ, isOpen_univ, preimage_univ⟩
isOpen_inter := by
rintro s₁ s₂ ⟨s'₁, hs₁, rfl⟩ ⟨s'₂, hs₂, rfl⟩
exact ⟨s'₁ ∩ s'₂, hs₁.inter hs₂, preimage_inter⟩
isOpen_sUnion S h := by
choose! g hgo hfg using h
refine ⟨⋃₀ (g '' S), isOpen_sUnion <| forall_mem_image.2 hgo, ?_⟩
rw [preimage_sUnion, biUnion_image, sUnion_eq_biUnion]
exact iUnion₂_congr hfg | def | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | induced | Given `f : X → Y` and a topology on `Y`,
the induced topology on `X` is the collection of sets
that are preimages of some open set in `Y`.
This is the coarsest topology that makes `f` continuous. |
_root_.instTopologicalSpaceSubtype {p : X → Prop} [t : TopologicalSpace X] :
TopologicalSpace (Subtype p) :=
induced (↑) t | instance | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | _root_.instTopologicalSpaceSubtype | null |
coinduced (f : X → Y) (t : TopologicalSpace X) : TopologicalSpace Y where
IsOpen s := IsOpen (f ⁻¹' s)
isOpen_univ := t.isOpen_univ
isOpen_inter _ _ h₁ h₂ := h₁.inter h₂
isOpen_sUnion s h := by simpa only [preimage_sUnion] using isOpen_biUnion h | def | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | coinduced | Given `f : X → Y` and a topology on `X`,
the coinduced topology on `Y` is defined such that
`s : Set Y` is open if the preimage of `s` is open.
This is the finest topology that makes `f` continuous. |
IsCoherentWith (S : Set (Set X)) : Prop where
isOpen_of_forall_induced (u : Set X) : (∀ s ∈ S, IsOpen ((↑) ⁻¹' u : Set s)) → IsOpen u
@[deprecated (since := "2025-04-08")] alias RestrictGenTopology := Topology.IsCoherentWith | structure | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | IsCoherentWith | We say that restrictions of the topology on `X` to sets from a family `S`
generates the original topology,
if either of the following equivalent conditions hold:
- a set which is relatively open in each `s ∈ S` is open;
- a set which is relatively closed in each `s ∈ S` is closed;
- for any topological space `Y`, a function `f : X → Y` is continuous
provided that it is continuous on each `s ∈ S`. |
@[mk_iff]
IsInducing (f : X → Y) : Prop where
/-- The topology on the domain is equal to the induced topology. -/
eq_induced : tX = tY.induced f | structure | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | IsInducing | A function `f : X → Y` between topological spaces is inducing if the topology on `X` is induced
by the topology on `Y` through `f`, meaning that a set `s : Set X` is open iff it is the preimage
under `f` of some open set `t : Set Y`. |
@[mk_iff]
IsEmbedding (f : X → Y) : Prop extends IsInducing f where
/-- A topological embedding is injective. -/
injective : Function.Injective f | structure | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | IsEmbedding | A function between topological spaces is an embedding if it is injective,
and for all `s : Set X`, `s` is open iff it is the preimage of an open set. |
@[mk_iff]
IsOpenEmbedding (f : X → Y) : Prop extends IsEmbedding f where
/-- The range of an open embedding is an open set. -/
isOpen_range : IsOpen <| range f | structure | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | IsOpenEmbedding | An open embedding is an embedding with open range. |
@[mk_iff]
IsClosedEmbedding (f : X → Y) : Prop extends IsEmbedding f where
/-- The range of a closed embedding is a closed set. -/
isClosed_range : IsClosed <| range f | structure | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | IsClosedEmbedding | A closed embedding is an embedding with closed image. |
@[mk_iff isQuotientMap_iff']
IsQuotientMap {X : Type*} {Y : Type*} [tX : TopologicalSpace X] [tY : TopologicalSpace Y]
(f : X → Y) : Prop where
surjective : Function.Surjective f
eq_coinduced : tY = tX.coinduced f | structure | Topology | [
"Mathlib.Data.Set.Lattice.Image",
"Mathlib.Topology.Basic"
] | Mathlib/Topology/Defs/Induced.lean | IsQuotientMap | A function between topological spaces is a quotient map if it is surjective,
and for all `s : Set Y`, `s` is open iff its preimage is an open set. |
seqClosure (s : Set X) : Set X :=
{ a | ∃ x : ℕ → X, (∀ n : ℕ, x n ∈ s) ∧ Tendsto x atTop (𝓝 a) } | def | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | seqClosure | The sequential closure of a set `s : Set X` in a topological space `X` is the set of all `a : X`
which arise as limit of sequences in `s`. Note that the sequential closure of a set is not
guaranteed to be sequentially closed. |
IsSeqClosed (s : Set X) : Prop :=
∀ ⦃x : ℕ → X⦄ ⦃p : X⦄, (∀ n, x n ∈ s) → Tendsto x atTop (𝓝 p) → p ∈ s | def | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | IsSeqClosed | A set `s` is sequentially closed if for any converging sequence `x n` of elements of `s`, the
limit belongs to `s` as well. Note that the sequential closure of a set is not guaranteed to be
sequentially closed. |
SeqContinuous (f : X → Y) : Prop :=
∀ ⦃x : ℕ → X⦄ ⦃p : X⦄, Tendsto x atTop (𝓝 p) → Tendsto (f ∘ x) atTop (𝓝 (f p)) | def | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | SeqContinuous | A function between topological spaces is sequentially continuous if it commutes with limit of
convergent sequences. |
IsSeqCompact (s : Set X) :=
∀ ⦃x : ℕ → X⦄, (∀ n, x n ∈ s) → ∃ a ∈ s, ∃ φ : ℕ → ℕ, StrictMono φ ∧ Tendsto (x ∘ φ) atTop (𝓝 a)
variable (X) | def | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | IsSeqCompact | A set `s` is sequentially compact if every sequence taking values in `s` has a
converging subsequence. |
@[mk_iff]
SeqCompactSpace : Prop where
isSeqCompact_univ : IsSeqCompact (univ : Set X)
export SeqCompactSpace (isSeqCompact_univ) | class | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | SeqCompactSpace | A space `X` is sequentially compact if every sequence in `X` has a
converging subsequence. |
FrechetUrysohnSpace : Prop where
closure_subset_seqClosure : ∀ s : Set X, closure s ⊆ seqClosure s | class | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | FrechetUrysohnSpace | A topological space is called a *Fréchet-Urysohn space*, if the sequential closure of any set
is equal to its closure. Since one of the inclusions is trivial, we require only the non-trivial one
in the definition. |
SequentialSpace : Prop where
isClosed_of_seq : ∀ s : Set X, IsSeqClosed s → IsClosed s
variable {X} | class | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | SequentialSpace | A topological space is said to be a *sequential space* if any sequentially closed set in this
space is closed. This condition is weaker than being a Fréchet-Urysohn space. |
protected IsSeqClosed.isClosed [SequentialSpace X] {s : Set X} (hs : IsSeqClosed s) :
IsClosed s :=
SequentialSpace.isClosed_of_seq s hs | theorem | Topology | [
"Mathlib.Order.Filter.AtTopBot.Defs",
"Mathlib.Topology.Defs.Filter"
] | Mathlib/Topology/Defs/Sequences.lean | IsSeqClosed.isClosed | In a sequential space, a sequentially closed set is closed. |
edist_le_Ico_sum_edist (f : ℕ → α) {m n} (h : m ≤ n) :
edist (f m) (f n) ≤ ∑ i ∈ Finset.Ico m n, edist (f i) (f (i + 1)) := by
induction n, h using Nat.le_induction with
| base => rw [Finset.Ico_self, Finset.sum_empty, edist_self]
| succ n hle ihn =>
calc
edist (f m) (f (n + 1)) ≤ edist (f m) (f n) + edist (f n) (f (n + 1)) := edist_triangle _ _ _
_ ≤ (∑ i ∈ Finset.Ico m n, _) + _ := add_le_add ihn le_rfl
_ = ∑ i ∈ Finset.Ico m (n + 1), _ := by
rw [← Finset.insert_Ico_right_eq_Ico_add_one hle, Finset.sum_insert, add_comm]; simp | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | edist_le_Ico_sum_edist | The triangle (polygon) inequality for sequences of points; `Finset.Ico` version. |
edist_le_range_sum_edist (f : ℕ → α) (n : ℕ) :
edist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, edist (f i) (f (i + 1)) :=
Nat.Ico_zero_eq_range ▸ edist_le_Ico_sum_edist f (Nat.zero_le n) | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | edist_le_range_sum_edist | The triangle (polygon) inequality for sequences of points; `Finset.range` version. |
edist_le_Ico_sum_of_edist_le {f : ℕ → α} {m n} (hmn : m ≤ n) {d : ℕ → ℝ≥0∞}
(hd : ∀ {k}, m ≤ k → k < n → edist (f k) (f (k + 1)) ≤ d k) :
edist (f m) (f n) ≤ ∑ i ∈ Finset.Ico m n, d i :=
le_trans (edist_le_Ico_sum_edist f hmn) <|
Finset.sum_le_sum fun _k hk => hd (Finset.mem_Ico.1 hk).1 (Finset.mem_Ico.1 hk).2 | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | edist_le_Ico_sum_of_edist_le | A version of `edist_le_Ico_sum_edist` with each intermediate distance replaced
with an upper estimate. |
edist_le_range_sum_of_edist_le {f : ℕ → α} (n : ℕ) {d : ℕ → ℝ≥0∞}
(hd : ∀ {k}, k < n → edist (f k) (f (k + 1)) ≤ d k) :
edist (f 0) (f n) ≤ ∑ i ∈ Finset.range n, d i :=
Nat.Ico_zero_eq_range ▸ edist_le_Ico_sum_of_edist_le (zero_le n) fun _ => hd | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | edist_le_range_sum_of_edist_le | A version of `edist_le_range_sum_edist` with each intermediate distance replaced
with an upper estimate. |
isUniformInducing_iff [PseudoEMetricSpace β] {f : α → β} :
IsUniformInducing f ↔ UniformContinuous f ∧
∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ :=
isUniformInducing_iff'.trans <| Iff.rfl.and <|
((uniformity_basis_edist.comap _).le_basis_iff uniformity_basis_edist).trans <| by
simp only [subset_def, Prod.forall]; rfl | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | isUniformInducing_iff | null |
controlled_of_isUniformEmbedding [PseudoEMetricSpace β] {f : α → β}
(h : IsUniformEmbedding f) :
(∀ ε > 0, ∃ δ > 0, ∀ {a b : α}, edist a b < δ → edist (f a) (f b) < ε) ∧
∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ :=
⟨uniformContinuous_iff.1 h.uniformContinuous, (isUniformEmbedding_iff.1 h).2.2⟩ | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | controlled_of_isUniformEmbedding | ε-δ characterization of uniform embeddings on pseudoemetric spaces -/
nonrec theorem isUniformEmbedding_iff [PseudoEMetricSpace β] {f : α → β} :
IsUniformEmbedding f ↔ Function.Injective f ∧ UniformContinuous f ∧
∀ δ > 0, ∃ ε > 0, ∀ {a b : α}, edist (f a) (f b) < ε → edist a b < δ :=
(isUniformEmbedding_iff _).trans <| and_comm.trans <| Iff.rfl.and isUniformInducing_iff
/-- If a map between pseudoemetric spaces is a uniform embedding then the edistance between `f x`
and `f y` is controlled in terms of the distance between `x` and `y`.
In fact, this lemma holds for a `IsUniformInducing` map.
TODO: generalize? |
protected cauchy_iff {f : Filter α} :
Cauchy f ↔ f ≠ ⊥ ∧ ∀ ε > 0, ∃ t ∈ f, ∀ x, x ∈ t → ∀ y, y ∈ t → edist x y < ε := by
rw [← neBot_iff]; exact uniformity_basis_edist.cauchy_iff | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | cauchy_iff | ε-δ characterization of Cauchy sequences on pseudoemetric spaces |
complete_of_convergent_controlled_sequences (B : ℕ → ℝ≥0∞) (hB : ∀ n, 0 < B n)
(H : ∀ u : ℕ → α, (∀ N n m : ℕ, N ≤ n → N ≤ m → edist (u n) (u m) < B N) →
∃ x, Tendsto u atTop (𝓝 x)) :
CompleteSpace α :=
UniformSpace.complete_of_convergent_controlled_sequences
(fun n => { p : α × α | edist p.1 p.2 < B n }) (fun n => edist_mem_uniformity <| hB n) H | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | complete_of_convergent_controlled_sequences | A very useful criterion to show that a space is complete is to show that all sequences
which satisfy a bound of the form `edist (u n) (u m) < B N` for all `n m ≥ N` are
converging. This is often applied for `B N = 2^{-N}`, i.e., with a very fast convergence to
`0`, which makes it possible to use arguments of converging series, while this is impossible
to do in general for arbitrary Cauchy sequences. |
complete_of_cauchySeq_tendsto :
(∀ u : ℕ → α, CauchySeq u → ∃ a, Tendsto u atTop (𝓝 a)) → CompleteSpace α :=
UniformSpace.complete_of_cauchySeq_tendsto | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | complete_of_cauchySeq_tendsto | A sequentially complete pseudoemetric space is complete. |
tendstoLocallyUniformlyOn_iff {ι : Type*} [TopologicalSpace β] {F : ι → β → α} {f : β → α}
{p : Filter ι} {s : Set β} :
TendstoLocallyUniformlyOn F f p s ↔
∀ ε > 0, ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, ∀ᶠ n in p, ∀ y ∈ t, edist (f y) (F n y) < ε := by
refine ⟨fun H ε hε => H _ (edist_mem_uniformity hε), fun H u hu x hx => ?_⟩
rcases mem_uniformity_edist.1 hu with ⟨ε, εpos, hε⟩
rcases H ε εpos x hx with ⟨t, ht, Ht⟩
exact ⟨t, ht, Ht.mono fun n hs x hx => hε (hs x hx)⟩ | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | tendstoLocallyUniformlyOn_iff | Expressing locally uniform convergence on a set using `edist`. |
tendstoUniformlyOn_iff {ι : Type*} {F : ι → β → α} {f : β → α} {p : Filter ι} {s : Set β} :
TendstoUniformlyOn F f p s ↔ ∀ ε > 0, ∀ᶠ n in p, ∀ x ∈ s, edist (f x) (F n x) < ε := by
refine ⟨fun H ε hε => H _ (edist_mem_uniformity hε), fun H u hu => ?_⟩
rcases mem_uniformity_edist.1 hu with ⟨ε, εpos, hε⟩
exact (H ε εpos).mono fun n hs x hx => hε (hs x hx) | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | tendstoUniformlyOn_iff | Expressing uniform convergence on a set using `edist`. |
tendstoLocallyUniformly_iff {ι : Type*} [TopologicalSpace β] {F : ι → β → α} {f : β → α}
{p : Filter ι} :
TendstoLocallyUniformly F f p ↔
∀ ε > 0, ∀ x : β, ∃ t ∈ 𝓝 x, ∀ᶠ n in p, ∀ y ∈ t, edist (f y) (F n y) < ε := by
simp only [← tendstoLocallyUniformlyOn_univ, tendstoLocallyUniformlyOn_iff, mem_univ,
forall_const, nhdsWithin_univ] | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | tendstoLocallyUniformly_iff | Expressing locally uniform convergence using `edist`. |
tendstoUniformly_iff {ι : Type*} {F : ι → β → α} {f : β → α} {p : Filter ι} :
TendstoUniformly F f p ↔ ∀ ε > 0, ∀ᶠ n in p, ∀ x, edist (f x) (F n x) < ε := by
simp only [← tendstoUniformlyOn_univ, tendstoUniformlyOn_iff, mem_univ, forall_const] | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | tendstoUniformly_iff | Expressing uniform convergence using `edist`. |
inseparable_iff : Inseparable x y ↔ edist x y = 0 := by
simp [inseparable_iff_mem_closure, mem_closure_iff, edist_comm, forall_gt_iff_le]
alias ⟨_root_.Inseparable.edist_eq_zero, _⟩ := EMetric.inseparable_iff | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | inseparable_iff | null |
cauchySeq_iff [Nonempty β] [SemilatticeSup β] {u : β → α} :
CauchySeq u ↔ ∀ ε > 0, ∃ N, ∀ m, N ≤ m → ∀ n, N ≤ n → edist (u m) (u n) < ε :=
uniformity_basis_edist.cauchySeq_iff | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | cauchySeq_iff | In a pseudoemetric space, Cauchy sequences are characterized by the fact that, eventually,
the pseudoedistance between its elements is arbitrarily small |
cauchySeq_iff' [Nonempty β] [SemilatticeSup β] {u : β → α} :
CauchySeq u ↔ ∀ ε > (0 : ℝ≥0∞), ∃ N, ∀ n ≥ N, edist (u n) (u N) < ε :=
uniformity_basis_edist.cauchySeq_iff' | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | cauchySeq_iff' | A variation around the emetric characterization of Cauchy sequences |
cauchySeq_iff_NNReal [Nonempty β] [SemilatticeSup β] {u : β → α} :
CauchySeq u ↔ ∀ ε : ℝ≥0, 0 < ε → ∃ N, ∀ n, N ≤ n → edist (u n) (u N) < ε :=
uniformity_basis_edist_nnreal.cauchySeq_iff' | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | cauchySeq_iff_NNReal | A variation of the emetric characterization of Cauchy sequences that deals with
`ℝ≥0` upper bounds. |
totallyBounded_iff {s : Set α} :
TotallyBounded s ↔ ∀ ε > 0, ∃ t : Set α, t.Finite ∧ s ⊆ ⋃ y ∈ t, ball y ε :=
⟨fun H _ε ε0 => H _ (edist_mem_uniformity ε0), fun H _r ru =>
let ⟨ε, ε0, hε⟩ := mem_uniformity_edist.1 ru
let ⟨t, ft, h⟩ := H ε ε0
⟨t, ft, h.trans <| iUnion₂_mono fun _ _ _ => hε⟩⟩ | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | totallyBounded_iff | null |
totallyBounded_iff' {s : Set α} :
TotallyBounded s ↔ ∀ ε > 0, ∃ t, t ⊆ s ∧ Set.Finite t ∧ s ⊆ ⋃ y ∈ t, ball y ε :=
⟨fun H _ε ε0 => (totallyBounded_iff_subset.1 H) _ (edist_mem_uniformity ε0), fun H _r ru =>
let ⟨ε, ε0, hε⟩ := mem_uniformity_edist.1 ru
let ⟨t, _, ft, h⟩ := H ε ε0
⟨t, ft, h.trans <| iUnion₂_mono fun _ _ _ => hε⟩⟩ | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | totallyBounded_iff' | null |
subset_countable_closure_of_compact {s : Set α} (hs : IsCompact s) :
∃ t, t ⊆ s ∧ t.Countable ∧ s ⊆ closure t := by
refine subset_countable_closure_of_almost_dense_set s fun ε hε => ?_
rcases totallyBounded_iff'.1 hs.totallyBounded ε hε with ⟨t, -, htf, hst⟩
exact ⟨t, htf.countable, hst.trans <| iUnion₂_mono fun _ _ => ball_subset_closedBall⟩ | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | subset_countable_closure_of_compact | A compact set in a pseudo emetric space is separable, i.e., it is a subset of the closure of a
countable set. |
EMetric.isUniformEmbedding_iff' [PseudoEMetricSpace β] {f : γ → β} :
IsUniformEmbedding f ↔
(∀ ε > 0, ∃ δ > 0, ∀ {a b : γ}, edist a b < δ → edist (f a) (f b) < ε) ∧
∀ δ > 0, ∃ ε > 0, ∀ {a b : γ}, edist (f a) (f b) < ε → edist a b < δ := by
rw [isUniformEmbedding_iff_isUniformInducing, isUniformInducing_iff, uniformContinuous_iff] | theorem | Topology | [
"Mathlib.Algebra.Order.BigOperators.Group.Finset",
"Mathlib.Algebra.Order.Interval.Finset.SuccPred",
"Mathlib.Data.Nat.SuccPred",
"Mathlib.Order.Interval.Finset.Nat",
"Mathlib.Topology.EMetricSpace.Defs",
"Mathlib.Topology.UniformSpace.Compact",
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence",... | Mathlib/Topology/EMetricSpace/Basic.lean | EMetric.isUniformEmbedding_iff' | A sigma compact pseudo emetric space has second countable topology. -/
instance (priority := 90) secondCountable_of_sigmaCompact [SigmaCompactSpace α] :
SecondCountableTopology α := by
suffices SeparableSpace α by exact UniformSpace.secondCountable_of_separable α
choose T _ hTc hsubT using fun n =>
subset_countable_closure_of_compact (isCompact_compactCovering α n)
refine ⟨⟨⋃ n, T n, countable_iUnion hTc, fun x => ?_⟩⟩
rcases iUnion_eq_univ_iff.1 (iUnion_compactCovering α) x with ⟨n, hn⟩
exact closure_mono (subset_iUnion _ n) (hsubT _ hn)
theorem secondCountable_of_almost_dense_set
(hs : ∀ ε > 0, ∃ t : Set α, t.Countable ∧ ⋃ x ∈ t, closedBall x ε = univ) :
SecondCountableTopology α := by
suffices SeparableSpace α from UniformSpace.secondCountable_of_separable α
have : ∀ ε > 0, ∃ t : Set α, Set.Countable t ∧ univ ⊆ ⋃ x ∈ t, closedBall x ε := by
simpa only [univ_subset_iff] using hs
rcases subset_countable_closure_of_almost_dense_set (univ : Set α) this with ⟨t, -, htc, ht⟩
exact ⟨⟨t, htc, fun x => ht (mem_univ x)⟩⟩
end SecondCountable
end EMetric
variable {γ : Type w} [EMetricSpace γ]
-- see Note [lower instance priority]
/-- An emetric space is separated -/
instance (priority := 100) EMetricSpace.instT0Space : T0Space γ where
t0 _ _ h := eq_of_edist_eq_zero <| inseparable_iff.1 h
/-- A map between emetric spaces is a uniform embedding if and only if the edistance between `f x`
and `f y` is controlled in terms of the distance between `x` and `y` and conversely. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.