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 ⌀ |
|---|---|---|---|---|---|---|
tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact (hs : IsCompact s) :
TendstoLocallyUniformlyOn F f p s ↔ TendstoUniformlyOn F f p s := by
haveI : CompactSpace s := isCompact_iff_compactSpace.mp hs
refine ⟨fun h => ?_, TendstoUniformlyOn.tendstoLocallyUniformlyOn⟩
rwa [tendstoLocallyUniformlyOn_iff_tendstoLocallyUniformly_comp_coe,
tendstoLocallyUniformly_iff_tendstoUniformly_of_compactSpace, ←
tendstoUniformlyOn_iff_tendstoUniformly_comp_coe] at h | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact | For a compact set `s`, locally uniform convergence on `s` is just uniform convergence on `s`. |
TendstoLocallyUniformlyOn.comp [TopologicalSpace γ] {t : Set γ}
(h : TendstoLocallyUniformlyOn F f p s) (g : γ → α) (hg : MapsTo g t s)
(cg : ContinuousOn g t) : TendstoLocallyUniformlyOn (fun n => F n ∘ g) (f ∘ g) p t := by
intro u hu x hx
rcases h u hu (g x) (hg hx) with ⟨a, ha, H⟩
have : g ⁻¹' a ∈ 𝓝[t] x :=
(cg x hx).preimage_mem_nhdsWithin' (nhdsWithin_mono (g x) hg.image_subset ha)
exact ⟨g ⁻¹' a, this, H.mono fun n hn y hy => hn _ hy⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | TendstoLocallyUniformlyOn.comp | null |
TendstoLocallyUniformly.comp [TopologicalSpace γ] (h : TendstoLocallyUniformly F f p)
(g : γ → α) (cg : Continuous g) : TendstoLocallyUniformly (fun n => F n ∘ g) (f ∘ g) p := by
rw [← tendstoLocallyUniformlyOn_univ] at h ⊢
rw [← continuousOn_univ] at cg
exact h.comp _ (mapsTo_univ _ _) cg | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | TendstoLocallyUniformly.comp | null |
tendstoLocallyUniformlyOn_of_forall_exists_nhds
(h : ∀ x ∈ s, ∃ t ∈ 𝓝[s] x, TendstoUniformlyOn F f p t) :
TendstoLocallyUniformlyOn F f p s := by
refine tendstoLocallyUniformlyOn_iff_forall_tendsto.mpr fun x hx ↦ ?_
obtain ⟨t, ht, htr⟩ := h x hx
rw [tendstoUniformlyOn_iff_tendsto] at htr
exact htr.mono_left <| prod_mono_right _ <| le_principal_iff.mpr ht
@[deprecated (since := "2025-05-22")] alias tendstoLocallyUniformlyOn_of_forall_exists_nhd :=
tendstoLocallyUniformlyOn_of_forall_exists_nhds | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformlyOn_of_forall_exists_nhds | If every `x ∈ s` has a neighbourhood within `s` on which `F i` tends uniformly to `f`, then
`F i` tends locally uniformly on `s` to `f`.
Note this is **not** a tautology, since our definition of `TendstoLocallyUniformlyOn` is slightly
more general (although the conditions are equivalent if `β` is locally compact and `s` is open,
see `tendstoLocallyUniformlyOn_TFAE`). |
tendstoLocallyUniformly_of_forall_exists_nhds
(h : ∀ x, ∃ t ∈ 𝓝 x, TendstoUniformlyOn F f p t) :
TendstoLocallyUniformly F f p :=
tendstoLocallyUniformlyOn_univ.mp
<| tendstoLocallyUniformlyOn_of_forall_exists_nhds (by simpa using h)
@[deprecated (since := "2025-05-22")] alias tendstoLocallyUniformly_of_forall_exists_nhd :=
tendstoLocallyUniformly_of_forall_exists_nhds | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformly_of_forall_exists_nhds | If every `x` has a neighbourhood on which `F i` tends uniformly to `f`, then `F i` tends
locally uniformly to `f`. (Special case of `tendstoLocallyUniformlyOn_of_forall_exists_nhds`
where `s = univ`.) |
tendstoLocallyUniformlyOn_TFAE [LocallyCompactSpace α] (G : ι → α → β) (g : α → β)
(p : Filter ι) (hs : IsOpen s) :
List.TFAE [
TendstoLocallyUniformlyOn G g p s,
∀ K, K ⊆ s → IsCompact K → TendstoUniformlyOn G g p K,
∀ x ∈ s, ∃ v ∈ 𝓝[s] x, TendstoUniformlyOn G g p v] := by
tfae_have 1 → 2
| h, K, hK1, hK2 =>
(tendstoLocallyUniformlyOn_iff_tendstoUniformlyOn_of_compact hK2).mp (h.mono hK1)
tfae_have 2 → 3
| h, x, hx => by
obtain ⟨K, ⟨hK1, hK2⟩, hK3⟩ := (compact_basis_nhds x).mem_iff.mp (hs.mem_nhds hx)
exact ⟨K, nhdsWithin_le_nhds hK1, h K hK3 hK2⟩
tfae_have 3 → 1
| h, u, hu, x, hx => by
obtain ⟨v, hv1, hv2⟩ := h x hx
exact ⟨v, hv1, hv2 u hu⟩
tfae_finish | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformlyOn_TFAE | null |
tendstoLocallyUniformlyOn_iff_forall_isCompact [LocallyCompactSpace α] (hs : IsOpen s) :
TendstoLocallyUniformlyOn F f p s ↔ ∀ K, K ⊆ s → IsCompact K → TendstoUniformlyOn F f p K :=
(tendstoLocallyUniformlyOn_TFAE F f p hs).out 0 1 | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformlyOn_iff_forall_isCompact | null |
tendstoLocallyUniformly_iff_forall_isCompact [LocallyCompactSpace α] :
TendstoLocallyUniformly F f p ↔ ∀ K : Set α, IsCompact K → TendstoUniformlyOn F f p K := by
simp only [← tendstoLocallyUniformlyOn_univ,
tendstoLocallyUniformlyOn_iff_forall_isCompact isOpen_univ, Set.subset_univ, forall_true_left] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformly_iff_forall_isCompact | null |
tendstoLocallyUniformlyOn_iff_filter :
TendstoLocallyUniformlyOn F f p s ↔ ∀ x ∈ s, TendstoUniformlyOnFilter F f p (𝓝[s] x) := by
simp only [TendstoUniformlyOnFilter, eventually_prod_iff]
constructor
· rintro h x hx u hu
obtain ⟨s, hs1, hs2⟩ := h u hu x hx
exact ⟨_, hs2, _, eventually_of_mem hs1 fun x => id, fun hi y hy => hi y hy⟩
· rintro h u hu x hx
obtain ⟨pa, hpa, pb, hpb, h⟩ := h x hx u hu
exact ⟨pb, hpb, eventually_of_mem hpa fun i hi y hy => h hi hy⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformlyOn_iff_filter | null |
tendstoLocallyUniformly_iff_filter :
TendstoLocallyUniformly F f p ↔ ∀ x, TendstoUniformlyOnFilter F f p (𝓝 x) := by
simpa [← tendstoLocallyUniformlyOn_univ, ← nhdsWithin_univ] using
@tendstoLocallyUniformlyOn_iff_filter _ _ _ _ _ F f univ p | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | tendstoLocallyUniformly_iff_filter | null |
TendstoLocallyUniformlyOn.tendsto_at (hf : TendstoLocallyUniformlyOn F f p s) {a : α}
(ha : a ∈ s) : Tendsto (fun i => F i a) p (𝓝 (f a)) := by
refine ((tendstoLocallyUniformlyOn_iff_filter.mp hf) a ha).tendsto_at ?_
simpa only [Filter.principal_singleton] using pure_le_nhdsWithin ha | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | TendstoLocallyUniformlyOn.tendsto_at | null |
TendstoLocallyUniformlyOn.unique [p.NeBot] [T2Space β] {g : α → β}
(hf : TendstoLocallyUniformlyOn F f p s) (hg : TendstoLocallyUniformlyOn F g p s) :
s.EqOn f g := fun _a ha => tendsto_nhds_unique (hf.tendsto_at ha) (hg.tendsto_at ha) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | TendstoLocallyUniformlyOn.unique | null |
TendstoLocallyUniformlyOn.congr {G : ι → α → β} (hf : TendstoLocallyUniformlyOn F f p s)
(hg : ∀ n, s.EqOn (F n) (G n)) : TendstoLocallyUniformlyOn G f p s := by
rintro u hu x hx
obtain ⟨t, ht, h⟩ := hf u hu x hx
refine ⟨s ∩ t, inter_mem self_mem_nhdsWithin ht, ?_⟩
filter_upwards [h] with i hi y hy using hg i hy.1 ▸ hi y hy.2 | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | TendstoLocallyUniformlyOn.congr | null |
TendstoLocallyUniformlyOn.congr_right {g : α → β} (hf : TendstoLocallyUniformlyOn F f p s)
(hg : s.EqOn f g) : TendstoLocallyUniformlyOn F g p s := by
rintro u hu x hx
obtain ⟨t, ht, h⟩ := hf u hu x hx
refine ⟨s ∩ t, inter_mem self_mem_nhdsWithin ht, ?_⟩
filter_upwards [h] with i hi y hy using hg hy.1 ▸ hi y hy.2 | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformConvergence"
] | Mathlib/Topology/UniformSpace/LocallyUniformConvergence.lean | TendstoLocallyUniformlyOn.congr_right | null |
instUniformSpace : UniformSpace (Matrix m n 𝕜) :=
(by infer_instance : UniformSpace (m → n → 𝕜)) | instance | Topology | [
"Mathlib.LinearAlgebra.Matrix.Defs",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/UniformSpace/Matrix.lean | instUniformSpace | null |
instIsUniformAddGroup [AddGroup 𝕜] [IsUniformAddGroup 𝕜] :
IsUniformAddGroup (Matrix m n 𝕜) :=
inferInstanceAs <| IsUniformAddGroup (m → n → 𝕜)
@[deprecated (since := "2025-03-31")] alias
instUniformAddGroup := Matrix.instIsUniformAddGroup | instance | Topology | [
"Mathlib.LinearAlgebra.Matrix.Defs",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/UniformSpace/Matrix.lean | instIsUniformAddGroup | null |
uniformity :
𝓤 (Matrix m n 𝕜) = ⨅ (i : m) (j : n), (𝓤 𝕜).comap fun a => (a.1 i j, a.2 i j) := by
erw [Pi.uniformity]
simp_rw [Pi.uniformity, Filter.comap_iInf, Filter.comap_comap]
rfl | theorem | Topology | [
"Mathlib.LinearAlgebra.Matrix.Defs",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/UniformSpace/Matrix.lean | uniformity | null |
uniformContinuous {β : Type*} [UniformSpace β] {f : β → Matrix m n 𝕜} :
UniformContinuous f ↔ ∀ i j, UniformContinuous fun x => f x i j := by
simp only [UniformContinuous, Matrix.uniformity, Filter.tendsto_iInf, Filter.tendsto_comap_iff]
apply Iff.intro <;> intro a <;> apply a | theorem | Topology | [
"Mathlib.LinearAlgebra.Matrix.Defs",
"Mathlib.Topology.Algebra.IsUniformGroup.Basic",
"Mathlib.Topology.UniformSpace.Pi"
] | Mathlib/Topology/UniformSpace/Matrix.lean | uniformContinuous | null |
uniformSpaceOfCompactT2 [TopologicalSpace γ] [CompactSpace γ] [T2Space γ] : UniformSpace γ where
uniformity := 𝓝ˢ (diagonal γ)
symm := continuous_swap.tendsto_nhdsSet fun _ => Eq.symm
comp := by
/-
This is the difficult part of the proof. We need to prove that, for each neighborhood `W`
of the diagonal `Δ`, there exists a smaller neighborhood `V` such that `V ○ V ⊆ W`.
-/
set 𝓝Δ := 𝓝ˢ (diagonal γ)
set F := 𝓝Δ.lift' fun s : Set (γ × γ) => s ○ s
rw [le_iff_forall_inf_principal_compl]
intro V V_in
by_contra H
haveI : NeBot (F ⊓ 𝓟 Vᶜ) := ⟨H⟩
obtain ⟨⟨x, y⟩, hxy⟩ : ∃ p : γ × γ, ClusterPt p (F ⊓ 𝓟 Vᶜ) := exists_clusterPt_of_compactSpace _
have clV : ClusterPt (x, y) (𝓟 <| Vᶜ) := hxy.of_inf_right
have : (x, y) ∉ interior V := by
have : (x, y) ∈ closure Vᶜ := by rwa [mem_closure_iff_clusterPt]
rwa [closure_compl] at this
have diag_subset : diagonal γ ⊆ interior V := subset_interior_iff_mem_nhdsSet.2 V_in
have x_ne_y : x ≠ y := mt (@diag_subset (x, y)) this
obtain
⟨U₁, _, V₁, V₁_in, U₂, _, V₂, V₂_in, V₁_cl, V₂_cl, U₁_op, U₂_op, VU₁, VU₂, hU₁₂⟩ :=
disjoint_nested_nhds x_ne_y
let U₃ := (V₁ ∪ V₂)ᶜ
have U₃_op : IsOpen U₃ := (V₁_cl.union V₂_cl).isOpen_compl
let W := U₁ ×ˢ U₁ ∪ U₂ ×ˢ U₂ ∪ U₃ ×ˢ U₃
have W_in : W ∈ 𝓝Δ := by
rw [mem_nhdsSet_iff_forall]
rintro ⟨z, z'⟩ (rfl : z = z')
refine IsOpen.mem_nhds ?_ ?_
· apply_rules [IsOpen.union, IsOpen.prod]
· simp only [W, mem_union, mem_prod, and_self_iff]
exact (_root_.em _).imp_left fun h => union_subset_union VU₁ VU₂ h
have : W ○ W ∈ F := by simpa only using mem_lift' W_in
have hV₁₂ : V₁ ×ˢ V₂ ∈ 𝓝 (x, y) := prod_mem_nhds V₁_in V₂_in
obtain ⟨⟨u, v⟩, ⟨u_in, v_in⟩, w, huw, hwv⟩ :=
clusterPt_iff_nonempty.mp hxy.of_inf_left hV₁₂ this
have uw_in : (u, w) ∈ U₁ ×ˢ U₁ :=
(huw.resolve_right fun h => h.1 <| Or.inl u_in).resolve_right fun h =>
hU₁₂.le_bot ⟨VU₁ u_in, h.1⟩
have wv_in : (w, v) ∈ U₂ ×ˢ U₂ :=
(hwv.resolve_right fun h => h.2 <| Or.inr v_in).resolve_left fun h =>
hU₁₂.le_bot ⟨h.2, VU₂ v_in⟩
exact hU₁₂.le_bot ⟨uw_in.2, wv_in.1⟩
nhds_eq_comap_uniformity x := by
simp_rw [nhdsSet_diagonal, comap_iSup, nhds_prod_eq, comap_prod, Function.comp_def, comap_id']
rw [iSup_split_single _ x, comap_const_of_mem fun V => mem_of_mem_nhds]
suffices ∀ y ≠ x, comap (fun _ : γ ↦ x) (𝓝 y) ⊓ 𝓝 y ≤ 𝓝 x by simpa
intro y hxy
simp [comap_const_of_notMem (compl_singleton_mem_nhds hxy) (not_not_intro rfl)]
... | def | Topology | [
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Defs"
] | Mathlib/Topology/UniformSpace/OfCompactT2.lean | uniformSpaceOfCompactT2 | The unique uniform structure inducing a given compact topological structure. |
ofFun [AddCommMonoid M] [PartialOrder M]
(d : X → X → M) (refl : ∀ x, d x x = 0)
(symm : ∀ x y, d x y = d y x) (triangle : ∀ x y z, d x z ≤ d x y + d y z)
(half : ∀ ε > (0 : M), ∃ δ > (0 : M), ∀ x < δ, ∀ y < δ, x + y < ε) :
UniformSpace X :=
.ofCore
{ uniformity := ⨅ r > 0, 𝓟 { x | d x.1 x.2 < r }
refl := le_iInf₂ fun r hr => principal_mono.2 <| idRel_subset.2 fun x => by simpa [refl]
symm := tendsto_iInf_iInf fun r => tendsto_iInf_iInf fun _ => tendsto_principal_principal.2
fun x hx => by rwa [mem_setOf, symm]
comp := le_iInf₂ fun r hr => let ⟨δ, h0, hδr⟩ := half r hr; le_principal_iff.2 <|
mem_of_superset
(mem_lift' <| mem_iInf_of_mem δ <| mem_iInf_of_mem h0 <| mem_principal_self _)
fun (x, z) ⟨y, h₁, h₂⟩ => (triangle _ _ _).trans_lt (hδr _ h₁ _ h₂) } | def | Topology | [
"Mathlib.Topology.UniformSpace.Defs"
] | Mathlib/Topology/UniformSpace/OfFun.lean | ofFun | Define a `UniformSpace` using a "distance" function. The function can be, e.g., the
distance in a (usual or extended) metric space or an absolute value on a ring. |
hasBasis_ofFun [AddCommMonoid M] [LinearOrder M]
(h₀ : ∃ x : M, 0 < x) (d : X → X → M) (refl : ∀ x, d x x = 0) (symm : ∀ x y, d x y = d y x)
(triangle : ∀ x y z, d x z ≤ d x y + d y z)
(half : ∀ ε > (0 : M), ∃ δ > (0 : M), ∀ x < δ, ∀ y < δ, x + y < ε) :
𝓤[.ofFun d refl symm triangle half].HasBasis ((0 : M) < ·) (fun ε => { x | d x.1 x.2 < ε }) :=
hasBasis_biInf_principal'
(fun ε₁ h₁ ε₂ h₂ => ⟨min ε₁ ε₂, lt_min h₁ h₂, fun _x hx => lt_of_lt_of_le hx (min_le_left _ _),
fun _x hx => lt_of_lt_of_le hx (min_le_right _ _)⟩) h₀
open scoped Topology in | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Defs"
] | Mathlib/Topology/UniformSpace/OfFun.lean | hasBasis_ofFun | null |
ofFunOfHasBasis [t : TopologicalSpace X] [AddCommMonoid M] [LinearOrder M]
(d : X → X → M) (refl : ∀ x, d x x = 0)
(symm : ∀ x y, d x y = d y x) (triangle : ∀ x y z, d x z ≤ d x y + d y z)
(half : ∀ ε > (0 : M), ∃ δ > (0 : M), ∀ x < δ, ∀ y < δ, x + y < ε)
(basis : ∀ x, (𝓝 x).HasBasis (fun ε ↦ 0 < ε) (fun ε ↦ {y | d x y < ε})) :
UniformSpace X where
toTopologicalSpace := t
nhds_eq_comap_uniformity x :=
(basis x).eq_of_same_basis <|
(hasBasis_ofFun (basis x).ex_mem d refl symm triangle half).comap (Prod.mk x)
__ := ofFun d refl symm triangle half | def | Topology | [
"Mathlib.Topology.UniformSpace.Defs"
] | Mathlib/Topology/UniformSpace/OfFun.lean | ofFunOfHasBasis | Define a `UniformSpace` using a "distance" function. The function can be, e.g., the
distance in a (usual or extended) metric space or an absolute value on a ring. We assume that
there is a preexisting topology, for which the neighborhoods can be expressed using the "distance",
and we make sure that the uniform space structure we construct has a topology which is defeq
to the original one. |
instUniformSpace : UniformSpace (Path x y) :=
.comap ((↑) : _ → C(I, X)) ContinuousMap.compactConvergenceUniformSpace | instance | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | instUniformSpace | null |
isUniformEmbedding_coe : IsUniformEmbedding ((↑) : Path x y → C(I, X)) where
comap_uniformity := rfl
injective := ContinuousMap.coe_injective' | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | isUniformEmbedding_coe | null |
uniformContinuous (γ : Path x y) : UniformContinuous γ :=
CompactSpace.uniformContinuous_of_continuous <| map_continuous _ | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | uniformContinuous | null |
uniformContinuous_extend (γ : Path x y) : UniformContinuous γ.extend :=
γ.uniformContinuous.comp <| LipschitzWith.projIcc _ |>.uniformContinuous | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | uniformContinuous_extend | Given a path `γ`, it extension to the real line `γ.extend : C(ℝ, X)`
is a uniformly continuous function. |
uniformContinuous_extend_left : UniformContinuous (Path.extend : Path x y → C(ℝ, X)) :=
ContinuousMap.projIccCM.uniformContinuous_comp_left.comp isUniformEmbedding_coe.uniformContinuous | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | uniformContinuous_extend_left | The function sending a path `γ` to its extension `γ.extend : ℝ → X`
is uniformly continuous in `γ`. |
_root_.Filter.HasBasis.uniformityPath {ι : Sort*} {p : ι → Prop} {U : ι → Set (X × X)}
(hU : (𝓤 X).HasBasis p U) :
(𝓤 (Path x y)).HasBasis p fun i ↦ {γ | ∀ t, (γ.1 t, γ.2 t) ∈ U i} :=
hU.compactConvergenceUniformity_of_compact.comap _ | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | _root_.Filter.HasBasis.uniformityPath | If `{U i | p i}` form a basis of entourages of `X`,
then the entourages `{V i | p i}`, `V i = {(γ₁, γ₂) | ∀ t, (γ₁ t, γ₂ t) ∈ U i}`,
form a basis of entourages of paths between `x` and `y`. |
hasBasis_uniformity :
(𝓤 (Path x y)).HasBasis (· ∈ 𝓤 X) ({γ | ∀ t, (γ.1 t, γ.2 t) ∈ ·}) :=
(𝓤 X).basis_sets.uniformityPath | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | hasBasis_uniformity | null |
uniformContinuous_symm : UniformContinuous (Path.symm : Path x y → Path y x) :=
hasBasis_uniformity.uniformContinuous_iff hasBasis_uniformity |>.mpr fun U hU ↦
⟨U, hU, fun _ _ h x ↦ h (σ x)⟩ | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | uniformContinuous_symm | null |
uniformContinuous_trans :
UniformContinuous (Path.trans : Path x y → Path y z → Path x z).uncurry :=
hasBasis_uniformity.uniformity_prod hasBasis_uniformity
|>.uniformContinuous_iff hasBasis_uniformity |>.mpr fun U hU ↦
⟨(U, U), ⟨hU, hU⟩, fun ⟨_, _⟩ ⟨_, _⟩ ⟨h₁, h₂⟩ t ↦ by
by_cases ht : (t : ℝ) ≤ 2⁻¹ <;> simp [Path.trans_apply, ht, h₁ _, h₂ _]⟩ | theorem | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | uniformContinuous_trans | The function `Path.trans` that concatenates two paths `γ₁ : Path x y` and `γ₂ : Path y z`
is uniformly continuous in `(γ₁, γ₂)`. |
instCompleteSpace [CompleteSpace X] : CompleteSpace (Path x y) :=
isUniformEmbedding_coe.completeSpace <| by simpa [Set.EqOn, range_coe]
using ContinuousMap.isComplete_setOf_eqOn (Function.update (fun _ : I ↦ y) 0 x) {0, 1} | instance | Topology | [
"Mathlib.Topology.Path",
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.HeineCantor",
"Mathlib.Topology.MetricSpace.Lipschitz",
"Mathlib.Topology.ContinuousMap.Interval"
] | Mathlib/Topology/UniformSpace/Path.lean | instCompleteSpace | The space of paths between two points in a complete uniform space
is a complete uniform space. |
Pi.uniformSpace : UniformSpace (∀ i, α i) :=
UniformSpace.ofCoreEq (⨅ i, UniformSpace.comap (eval i) (U i)).toCore
Pi.topologicalSpace <|
Eq.symm toTopologicalSpace_iInf | instance | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformSpace | null |
Pi.uniformSpace_eq :
Pi.uniformSpace α = ⨅ i, UniformSpace.comap (eval i) (U i) := by
ext : 1; rfl | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformSpace_eq | null |
Pi.uniformity :
𝓤 (∀ i, α i) = ⨅ i : ι, (Filter.comap fun a => (a.1 i, a.2 i)) (𝓤 (α i)) :=
iInf_uniformity
variable {α} | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformity | null |
uniformContinuous_pi {β : Type*} [UniformSpace β] {f : β → ∀ i, α i} :
UniformContinuous f ↔ ∀ i, UniformContinuous fun x => f x i := by
simp only [UniformContinuous, Pi.uniformity, tendsto_iInf, tendsto_comap_iff, Function.comp_def]
variable (α) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | uniformContinuous_pi | null |
Pi.uniformContinuous_proj (i : ι) : UniformContinuous fun a : ∀ i : ι, α i => a i :=
uniformContinuous_pi.1 uniformContinuous_id i | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformContinuous_proj | null |
Pi.uniformContinuous_precomp' (φ : ι' → ι) :
UniformContinuous (fun (f : (∀ i, α i)) (j : ι') ↦ f (φ j)) :=
uniformContinuous_pi.mpr fun j ↦ uniformContinuous_proj α (φ j) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformContinuous_precomp' | null |
Pi.uniformContinuous_precomp (φ : ι' → ι) :
UniformContinuous (· ∘ φ : (ι → β) → (ι' → β)) :=
Pi.uniformContinuous_precomp' _ φ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformContinuous_precomp | null |
Pi.uniformContinuous_postcomp' {β : ι → Type*} [∀ i, UniformSpace (β i)]
{g : ∀ i, α i → β i} (hg : ∀ i, UniformContinuous (g i)) :
UniformContinuous (fun (f : (∀ i, α i)) (i : ι) ↦ g i (f i)) :=
uniformContinuous_pi.mpr fun i ↦ (hg i).comp <| uniformContinuous_proj α i | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformContinuous_postcomp' | null |
Pi.uniformContinuous_postcomp {α : Type*} [UniformSpace α] {g : α → β}
(hg : UniformContinuous g) : UniformContinuous (g ∘ · : (ι → α) → (ι → β)) :=
Pi.uniformContinuous_postcomp' _ fun _ ↦ hg | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformContinuous_postcomp | null |
Pi.uniformSpace_comap_precomp' (φ : ι' → ι) :
UniformSpace.comap (fun g i' ↦ g (φ i')) (Pi.uniformSpace (fun i' ↦ α (φ i'))) =
⨅ i', UniformSpace.comap (eval (φ i')) (U (φ i')) := by
simp [Pi.uniformSpace_eq, UniformSpace.comap_iInf, ← UniformSpace.comap_comap, comp_def] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformSpace_comap_precomp' | null |
Pi.uniformSpace_comap_precomp (φ : ι' → ι) :
UniformSpace.comap (· ∘ φ) (Pi.uniformSpace (fun _ ↦ β)) =
⨅ i', UniformSpace.comap (eval (φ i')) ‹UniformSpace β› :=
uniformSpace_comap_precomp' (fun _ ↦ β) φ | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformSpace_comap_precomp | null |
Pi.uniformContinuous_restrict (S : Set ι) :
UniformContinuous (S.restrict : (∀ i : ι, α i) → (∀ i : S, α i)) :=
Pi.uniformContinuous_precomp' _ ((↑) : S → ι) | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformContinuous_restrict | null |
Pi.uniformSpace_comap_restrict (S : Set ι) :
UniformSpace.comap (S.restrict) (Pi.uniformSpace (fun i : S ↦ α i)) =
⨅ i ∈ S, UniformSpace.comap (eval i) (U i) := by
simp +unfoldPartialApp
[← iInf_subtype'', ← uniformSpace_comap_precomp' _ ((↑) : S → ι), Set.restrict] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformSpace_comap_restrict | null |
cauchy_pi_iff [Nonempty ι] {l : Filter (∀ i, α i)} :
Cauchy l ↔ ∀ i, Cauchy (map (eval i) l) := by
simp_rw [Pi.uniformSpace_eq, cauchy_iInf_uniformSpace, cauchy_comap_uniformSpace] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | cauchy_pi_iff | null |
cauchy_pi_iff' {l : Filter (∀ i, α i)} [l.NeBot] :
Cauchy l ↔ ∀ i, Cauchy (map (eval i) l) := by
simp_rw [Pi.uniformSpace_eq, cauchy_iInf_uniformSpace', cauchy_comap_uniformSpace] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | cauchy_pi_iff' | null |
Cauchy.pi [Nonempty ι] {l : ∀ i, Filter (α i)} (hl : ∀ i, Cauchy (l i)) :
Cauchy (Filter.pi l) := by
have := fun i ↦ (hl i).1
simpa [cauchy_pi_iff] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Cauchy.pi | null |
Pi.complete [∀ i, CompleteSpace (α i)] : CompleteSpace (∀ i, α i) where
complete {f} hf := by
have := hf.1
simp_rw [cauchy_pi_iff', cauchy_iff_exists_le_nhds] at hf
choose x hx using hf
use x
rwa [nhds_pi, le_pi] | instance | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.complete | null |
Pi.uniformSpace_comap_restrict_sUnion (𝔖 : Set (Set ι)) :
UniformSpace.comap (⋃₀ 𝔖).restrict (Pi.uniformSpace (fun i : (⋃₀ 𝔖) ↦ α i)) =
⨅ S ∈ 𝔖, UniformSpace.comap S.restrict (Pi.uniformSpace (fun i : S ↦ α i)) := by
simp_rw [Pi.uniformSpace_comap_restrict α, iInf_sUnion]
/- An infimum of complete uniformities is complete,
as long as the whole family is bounded by some common T2 topology. -/ | lemma | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | Pi.uniformSpace_comap_restrict_sUnion | null |
protected CompleteSpace.iInf {ι X : Type*} {u : ι → UniformSpace X}
(hu : ∀ i, @CompleteSpace X (u i))
(ht : ∃ t, @T2Space X t ∧ ∀ i, (u i).toTopologicalSpace ≤ t) :
@CompleteSpace X (⨅ i, u i) := by
nontriviality X
rcases ht with ⟨t, ht, hut⟩
have : @IsUniformInducing X (ι → X) (⨅ i, u i) (Pi.uniformSpace (U := u)) (const ι) := by
simp_rw [isUniformInducing_iff, iInf_uniformity, Pi.uniformity, Filter.comap_iInf,
Filter.comap_comap, comp_def, const, Prod.eta, comap_id']
simp_rw [@completeSpace_iff_isComplete_range _ _ (_) (_) _ this, range_const_eq_diagonal,
setOf_forall]
have : Pi.topologicalSpace (t₂ := fun i ↦ (u i).toTopologicalSpace) ≤
Pi.topologicalSpace (t₂ := fun _ ↦ t) :=
iInf_mono fun i ↦ induced_mono <| hut i
refine IsClosed.isComplete <| .mono ?_ this
exact isClosed_iInter fun i ↦ isClosed_iInter fun j ↦
isClosed_eq (continuous_apply _) (continuous_apply _) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding"
] | Mathlib/Topology/UniformSpace/Pi.lean | CompleteSpace.iInf | null |
exists_finite_sum_smul_approximation_of_mem_uniformity [TopologicalSpace R]
[MonoidWithZero R] [MulActionWithZero R V] (f : C(X × Y, V)) (hS : S ∈ 𝓤 V) :
∃ (n : ℕ) (g : Fin n → C(X, R)) (h : Fin n → C(Y, V)),
∀ x y, (f (x, y), ∑ i, g i x • h i y) ∈ S := by
have hS' : {(f, g) | ∀ y, (f y, g y) ∈ S} ∈ 𝓤 C(Y, V) :=
(mem_compactConvergence_entourage_iff _).mpr
⟨_, _, isCompact_univ, hS, by simp only [Set.mem_univ, true_implies, subset_refl]⟩
obtain ⟨n, U, v, hv⟩ := exists_finite_sum_const_indicator_approximation_of_mem_nhds_diagonal
f.curry (nhdsSet_diagonal_le_uniformity hS')
refine ⟨n, fun i ↦ ⟨_, (U i).isClopen.continuous_indicator <| continuous_const (y := 1)⟩,
v, fun x y ↦ ?_⟩
convert hv x y using 2
simp only [sum_apply]
congr 1 with i
by_cases hi : x ∈ U i <;> simp [hi] | lemma | Topology | [
"Mathlib.Topology.Algebra.Indicator",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Separation.DisjointCover"
] | Mathlib/Topology/UniformSpace/ProdApproximation.lean | exists_finite_sum_smul_approximation_of_mem_uniformity | A continuous function on `X × Y`, taking values in an `R`-module with a uniform structure,
can be uniformly approximated by sums of functions of the form `(x, y) ↦ f x • g y`.
Note that no continuity properties are assumed either for multiplication on `R`, or for the scalar
multiplication of `R` on `V`. |
exists_finite_sum_mul_approximation_of_mem_uniformity [Ring R] [UniformSpace R]
[IsUniformAddGroup R] (f : C(X × Y, R)) {S : Set (R × R)} (hS : S ∈ 𝓤 R) :
∃ (n : ℕ) (g : Fin n → C(X, R)) (h : Fin n → C(Y, R)),
∀ x y, (f (x, y), ∑ i, g i x * h i y) ∈ S :=
exists_finite_sum_smul_approximation_of_mem_uniformity f hS | lemma | Topology | [
"Mathlib.Topology.Algebra.Indicator",
"Mathlib.Topology.ContinuousMap.Algebra",
"Mathlib.Topology.Separation.DisjointCover"
] | Mathlib/Topology/UniformSpace/ProdApproximation.lean | exists_finite_sum_mul_approximation_of_mem_uniformity | A continuous function on `X × Y`, taking values in a ring `R` equipped with a uniformity
compatible with addition, can be uniformly approximated by sums of functions of the form
`(x, y) ↦ f x * g y`.
Note that no assumption is needed relating the multiplication on `R` to the uniformity. |
Real.instCompleteSpace : CompleteSpace ℝ := by
apply complete_of_cauchySeq_tendsto
intro u hu
let c : CauSeq ℝ abs := ⟨u, Metric.cauchySeq_iff'.1 hu⟩
refine ⟨c.lim, fun s h => ?_⟩
rcases Metric.mem_nhds_iff.1 h with ⟨ε, ε0, hε⟩
have := c.equiv_lim ε ε0
simp only [mem_map, mem_atTop_sets]
exact this.imp fun N hN n hn => hε (hN n hn) | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.MetricSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/Real.lean | Real.instCompleteSpace | null |
@[fun_prop]
continuous_coe : Continuous ((↑) : ℝ≥0 → ℝ) :=
continuous_subtype_val | theorem | Topology | [
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.MetricSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/Real.lean | continuous_coe | null |
@[simps -fullyApplied]
_root_.ContinuousMap.coeNNRealReal : C(ℝ≥0, ℝ) :=
⟨(↑), continuous_coe⟩
@[simp] | def | Topology | [
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.MetricSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/Real.lean | _root_.ContinuousMap.coeNNRealReal | Embedding of `ℝ≥0` to `ℝ` as a bundled continuous map. |
coeNNRealReal_zero : ContinuousMap.coeNNRealReal 0 = 0 := rfl | lemma | Topology | [
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.MetricSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/Real.lean | coeNNRealReal_zero | null |
ContinuousMap.canLift {X : Type*} [TopologicalSpace X] :
CanLift C(X, ℝ) C(X, ℝ≥0) ContinuousMap.coeNNRealReal.comp fun f => ∀ x, 0 ≤ f x where
prf f hf := ⟨⟨fun x => ⟨f x, hf x⟩, f.2.subtype_mk _⟩, DFunLike.ext' rfl⟩ | instance | Topology | [
"Mathlib.Topology.ContinuousMap.Basic",
"Mathlib.Topology.MetricSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/Real.lean | ContinuousMap.canLift | null |
Filter.HasBasis.specializes_iff_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)}
(h : (𝓤 α).HasBasis p s) {x y : α} : x ⤳ y ↔ ∀ i, p i → (x, y) ∈ s i :=
(nhds_basis_uniformity h).specializes_iff | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | Filter.HasBasis.specializes_iff_uniformity | null |
Filter.HasBasis.inseparable_iff_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)}
(h : (𝓤 α).HasBasis p s) {x y : α} : Inseparable x y ↔ ∀ i, p i → (x, y) ∈ s i :=
specializes_iff_inseparable.symm.trans h.specializes_iff_uniformity | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | Filter.HasBasis.inseparable_iff_uniformity | null |
inseparable_iff_ker_uniformity {x y : α} : Inseparable x y ↔ (x, y) ∈ (𝓤 α).ker :=
(𝓤 α).basis_sets.inseparable_iff_uniformity | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | inseparable_iff_ker_uniformity | null |
protected Inseparable.nhds_le_uniformity {x y : α} (h : Inseparable x y) :
𝓝 (x, y) ≤ 𝓤 α := by
rw [h.prod rfl]
apply nhds_le_uniformity | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | Inseparable.nhds_le_uniformity | null |
inseparable_iff_clusterPt_uniformity {x y : α} :
Inseparable x y ↔ ClusterPt (x, y) (𝓤 α) := by
refine ⟨fun h ↦ .of_nhds_le h.nhds_le_uniformity, fun h ↦ ?_⟩
simp_rw [uniformity_hasBasis_closed.inseparable_iff_uniformity, isClosed_iff_clusterPt]
exact fun U ⟨hU, hUc⟩ ↦ hUc _ <| h.mono <| le_principal_iff.2 hU | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | inseparable_iff_clusterPt_uniformity | null |
t0Space_iff_uniformity :
T0Space α ↔ ∀ x y, (∀ r ∈ 𝓤 α, (x, y) ∈ r) → x = y := by
simp only [t0Space_iff_inseparable, inseparable_iff_ker_uniformity, mem_ker] | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | t0Space_iff_uniformity | null |
t0Space_iff_uniformity' :
T0Space α ↔ Pairwise fun x y ↦ ∃ r ∈ 𝓤 α, (x, y) ∉ r := by
simp [t0Space_iff_not_inseparable, inseparable_iff_ker_uniformity] | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | t0Space_iff_uniformity' | null |
t0Space_iff_ker_uniformity : T0Space α ↔ (𝓤 α).ker = diagonal α := by
simp_rw [t0Space_iff_uniformity, subset_antisymm_iff, diagonal_subset_iff, subset_def,
Prod.forall, Filter.mem_ker, mem_diagonal_iff, iff_self_and]
exact fun _ x s hs ↦ refl_mem_uniformity hs | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | t0Space_iff_ker_uniformity | null |
eq_of_uniformity {α : Type*} [UniformSpace α] [T0Space α] {x y : α}
(h : ∀ {V}, V ∈ 𝓤 α → (x, y) ∈ V) : x = y :=
t0Space_iff_uniformity.mp ‹T0Space α› x y @h | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | eq_of_uniformity | null |
eq_of_uniformity_basis {α : Type*} [UniformSpace α] [T0Space α] {ι : Sort*}
{p : ι → Prop} {s : ι → Set (α × α)} (hs : (𝓤 α).HasBasis p s) {x y : α}
(h : ∀ {i}, p i → (x, y) ∈ s i) : x = y :=
(hs.inseparable_iff_uniformity.2 @h).eq | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | eq_of_uniformity_basis | null |
eq_of_forall_symmetric {α : Type*} [UniformSpace α] [T0Space α] {x y : α}
(h : ∀ {V}, V ∈ 𝓤 α → IsSymmetricRel V → (x, y) ∈ V) : x = y :=
eq_of_uniformity_basis hasBasis_symmetric (by simpa) | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | eq_of_forall_symmetric | null |
eq_of_clusterPt_uniformity [T0Space α] {x y : α} (h : ClusterPt (x, y) (𝓤 α)) : x = y :=
(inseparable_iff_clusterPt_uniformity.2 h).eq | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | eq_of_clusterPt_uniformity | null |
Filter.Tendsto.inseparable_iff_uniformity {β} {l : Filter β} [NeBot l] {f g : β → α}
{a b : α} (ha : Tendsto f l (𝓝 a)) (hb : Tendsto g l (𝓝 b)) :
Inseparable a b ↔ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α) := by
refine ⟨fun h ↦ (ha.prodMk_nhds hb).mono_right h.nhds_le_uniformity, fun h ↦ ?_⟩
rw [inseparable_iff_clusterPt_uniformity]
exact (ClusterPt.of_le_nhds (ha.prodMk_nhds hb)).mono h | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | Filter.Tendsto.inseparable_iff_uniformity | null |
isClosed_of_spaced_out [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α) {s : Set α}
(hs : s.Pairwise fun x y => (x, y) ∉ V₀) : IsClosed s := by
rcases comp_symm_mem_uniformity_sets V₀_in with ⟨V₁, V₁_in, V₁_symm, h_comp⟩
apply isClosed_of_closure_subset
intro x hx
rw [mem_closure_iff_ball] at hx
rcases hx V₁_in with ⟨y, hy, hy'⟩
suffices x = y by rwa [this]
apply eq_of_forall_symmetric
intro V V_in _
rcases hx (inter_mem V₁_in V_in) with ⟨z, hz, hz'⟩
obtain rfl : z = y := by
by_contra hzy
exact hs hz' hy' hzy (h_comp <| mem_comp_of_mem_ball V₁_symm (ball_inter_left x _ _ hz) hy)
exact ball_inter_right x _ _ hz | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | isClosed_of_spaced_out | null |
isClosed_range_of_spaced_out {ι} [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α)
{f : ι → α} (hf : Pairwise fun x y => (f x, f y) ∉ V₀) : IsClosed (range f) :=
isClosed_of_spaced_out V₀_in <| by
rintro _ ⟨x, rfl⟩ _ ⟨y, rfl⟩ h
exact hf (ne_of_apply_ne f h)
/-! | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | isClosed_range_of_spaced_out | null |
comap_map_mk_uniformity : comap (Prod.map mk mk) (map (Prod.map mk mk) (𝓤 α)) = 𝓤 α := by
refine le_antisymm ?_ le_comap_map
refine ((((𝓤 α).basis_sets.map _).comap _).le_basis_iff uniformity_hasBasis_open).2 fun U hU ↦ ?_
refine ⟨U, hU.1, fun (x₁, x₂) ⟨(y₁, y₂), hyU, hxy⟩ ↦ ?_⟩
simp only [Prod.map, Prod.ext_iff, mk_eq_mk] at hxy
exact ((hxy.1.prod hxy.2).mem_open_iff hU.2).1 hyU | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | comap_map_mk_uniformity | null |
instUniformSpace : UniformSpace (SeparationQuotient α) where
uniformity := map (Prod.map mk mk) (𝓤 α)
symm := tendsto_map' <| tendsto_map.comp tendsto_swap_uniformity
comp := fun t ht ↦ by
rcases comp_open_symm_mem_uniformity_sets ht with ⟨U, hU, hUo, -, hUt⟩
refine mem_of_superset (mem_lift' <| image_mem_map hU) ?_
simp only [subset_def, Prod.forall, mem_compRel, mem_image, Prod.ext_iff]
rintro _ _ ⟨_, ⟨⟨x, y⟩, hxyU, rfl, rfl⟩, ⟨⟨y', z⟩, hyzU, hy, rfl⟩⟩
have : y' ⤳ y := (mk_eq_mk.1 hy).specializes
exact @hUt (x, z) ⟨y', this.mem_open (UniformSpace.isOpen_ball _ hUo) hxyU, hyzU⟩
nhds_eq_comap_uniformity := surjective_mk.forall.2 fun x ↦ comap_injective surjective_mk <| by
conv_lhs => rw [comap_mk_nhds_mk, nhds_eq_comap_uniformity, ← comap_map_mk_uniformity]
simp only [Filter.comap_comap, Function.comp_def, Prod.map_apply] | instance | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | instUniformSpace | null |
uniformity_eq : 𝓤 (SeparationQuotient α) = (𝓤 α).map (Prod.map mk mk) := rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformity_eq | null |
uniformContinuous_mk : UniformContinuous (mk : α → SeparationQuotient α) :=
le_rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformContinuous_mk | null |
uniformContinuous_dom {f : SeparationQuotient α → β} :
UniformContinuous f ↔ UniformContinuous (f ∘ mk) :=
.rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformContinuous_dom | null |
uniformContinuous_dom₂ {f : SeparationQuotient α × SeparationQuotient β → γ} :
UniformContinuous f ↔ UniformContinuous fun p : α × β ↦ f (mk p.1, mk p.2) := by
simp only [UniformContinuous, uniformity_prod_eq_prod, uniformity_eq, prod_map_map_eq,
tendsto_map'_iff]
rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformContinuous_dom₂ | null |
uniformContinuous_lift {f : α → β} (h : ∀ a b, Inseparable a b → f a = f b) :
UniformContinuous (lift f h) ↔ UniformContinuous f :=
.rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformContinuous_lift | null |
uniformContinuous_uncurry_lift₂ {f : α → β → γ}
(h : ∀ a c b d, Inseparable a b → Inseparable c d → f a c = f b d) :
UniformContinuous (uncurry <| lift₂ f h) ↔ UniformContinuous (uncurry f) :=
uniformContinuous_dom₂ | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformContinuous_uncurry_lift₂ | null |
comap_mk_uniformity : (𝓤 (SeparationQuotient α)).comap (Prod.map mk mk) = 𝓤 α :=
comap_map_mk_uniformity
open Classical in | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | comap_mk_uniformity | null |
lift' [T0Space β] (f : α → β) : SeparationQuotient α → β :=
if hc : UniformContinuous f then lift f fun _ _ h => (h.map hc.continuous).eq
else fun x => f (Nonempty.some ⟨x.out⟩) | def | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | lift' | Factoring functions to a separated space through the separation quotient.
TODO: unify with `SeparationQuotient.lift`. |
lift'_mk [T0Space β] {f : α → β} (h : UniformContinuous f) (a : α) :
lift' f (mk a) = f a := by rw [lift', dif_pos h, lift_mk] | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | lift'_mk | null |
uniformContinuous_lift' [T0Space β] (f : α → β) : UniformContinuous (lift' f) := by
by_cases hf : UniformContinuous f
· rwa [lift', dif_pos hf, uniformContinuous_lift]
· rw [lift', dif_neg hf]
exact uniformContinuous_of_const fun a _ => rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformContinuous_lift' | null |
map (f : α → β) : SeparationQuotient α → SeparationQuotient β := lift' (mk ∘ f) | def | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | map | The separation quotient functor acting on functions. |
map_mk {f : α → β} (h : UniformContinuous f) (a : α) : map f (mk a) = mk (f a) := by
rw [map, lift'_mk (uniformContinuous_mk.comp h)]; rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | map_mk | null |
uniformContinuous_map (f : α → β) : UniformContinuous (map f) :=
uniformContinuous_lift' _ | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | uniformContinuous_map | null |
map_unique {f : α → β} (hf : UniformContinuous f)
{g : SeparationQuotient α → SeparationQuotient β} (comm : mk ∘ f = g ∘ mk) : map f = g := by
ext ⟨a⟩
calc
map f ⟦a⟧ = ⟦f a⟧ := map_mk hf a
_ = g ⟦a⟧ := congr_fun comm a
@[simp] | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | map_unique | null |
map_id : map (@id α) = id := map_unique uniformContinuous_id rfl | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | map_id | null |
map_comp {f : α → β} {g : β → γ} (hf : UniformContinuous f) (hg : UniformContinuous g) :
map g ∘ map f = map (g ∘ f) :=
(map_unique (hg.comp hf) <| by simp only [Function.comp_def, map_mk, hf, hg]).symm | theorem | Topology | [
"Mathlib.Tactic.ApplyFun",
"Mathlib.Topology.Separation.Regular",
"Mathlib.Topology.UniformSpace.Basic"
] | Mathlib/Topology/UniformSpace/Separation.lean | map_comp | null |
continuousWithinAt_of_locally_uniform_approx_of_continuousWithinAt (hx : x ∈ s)
(L : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝[s] x, ∃ F : α → β, ContinuousWithinAt F s x ∧ ∀ y ∈ t, (f y, F y) ∈ u) :
ContinuousWithinAt f s x := by
refine Uniform.continuousWithinAt_iff'_left.2 fun u₀ hu₀ => ?_
obtain ⟨u₁, h₁, u₁₀⟩ : ∃ u ∈ 𝓤 β, u ○ u ⊆ u₀ := comp_mem_uniformity_sets hu₀
obtain ⟨u₂, h₂, hsymm, u₂₁⟩ : ∃ u ∈ 𝓤 β, (∀ {a b}, (a, b) ∈ u → (b, a) ∈ u) ∧ u ○ u ⊆ u₁ :=
comp_symm_of_uniformity h₁
rcases L u₂ h₂ with ⟨t, tx, F, hFc, hF⟩
have A : ∀ᶠ y in 𝓝[s] x, (f y, F y) ∈ u₂ := Eventually.mono tx hF
have B : ∀ᶠ y in 𝓝[s] x, (F y, F x) ∈ u₂ := Uniform.continuousWithinAt_iff'_left.1 hFc h₂
have C : ∀ᶠ y in 𝓝[s] x, (f y, F x) ∈ u₁ :=
(A.and B).mono fun y hy => u₂₁ (prodMk_mem_compRel hy.1 hy.2)
have : (F x, f x) ∈ u₁ :=
u₂₁ (prodMk_mem_compRel (refl_mem_uniformity h₂) (hsymm (A.self_of_nhdsWithin hx)))
exact C.mono fun y hy => u₁₀ (prodMk_mem_compRel hy this) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | continuousWithinAt_of_locally_uniform_approx_of_continuousWithinAt | A function which can be locally uniformly approximated by functions which are continuous
within a set at a point is continuous within this set at this point. |
continuousAt_of_locally_uniform_approx_of_continuousAt
(L : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝 x, ∃ F, ContinuousAt F x ∧ ∀ y ∈ t, (f y, F y) ∈ u) :
ContinuousAt f x := by
rw [← continuousWithinAt_univ]
apply continuousWithinAt_of_locally_uniform_approx_of_continuousWithinAt (mem_univ _) _
simpa only [exists_prop, nhdsWithin_univ, continuousWithinAt_univ] using L | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | continuousAt_of_locally_uniform_approx_of_continuousAt | A function which can be locally uniformly approximated by functions which are continuous at
a point is continuous at this point. |
continuousOn_of_locally_uniform_approx_of_continuousWithinAt
(L : ∀ x ∈ s, ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝[s] x, ∃ F,
ContinuousWithinAt F s x ∧ ∀ y ∈ t, (f y, F y) ∈ u) :
ContinuousOn f s := fun x hx =>
continuousWithinAt_of_locally_uniform_approx_of_continuousWithinAt hx (L x hx) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | continuousOn_of_locally_uniform_approx_of_continuousWithinAt | A function which can be locally uniformly approximated by functions which are continuous
on a set is continuous on this set. |
continuousOn_of_uniform_approx_of_continuousOn
(L : ∀ u ∈ 𝓤 β, ∃ F, ContinuousOn F s ∧ ∀ y ∈ s, (f y, F y) ∈ u) : ContinuousOn f s :=
continuousOn_of_locally_uniform_approx_of_continuousWithinAt fun _x hx u hu =>
⟨s, self_mem_nhdsWithin, (L u hu).imp fun _F hF => ⟨hF.1.continuousWithinAt hx, hF.2⟩⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | continuousOn_of_uniform_approx_of_continuousOn | A function which can be uniformly approximated by functions which are continuous on a set
is continuous on this set. |
continuous_of_locally_uniform_approx_of_continuousAt
(L : ∀ x : α, ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝 x, ∃ F, ContinuousAt F x ∧ ∀ y ∈ t, (f y, F y) ∈ u) :
Continuous f :=
continuous_iff_continuousAt.2 fun x =>
continuousAt_of_locally_uniform_approx_of_continuousAt (L x) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | continuous_of_locally_uniform_approx_of_continuousAt | A function which can be locally uniformly approximated by continuous functions is continuous. |
continuous_of_uniform_approx_of_continuous
(L : ∀ u ∈ 𝓤 β, ∃ F, Continuous F ∧ ∀ y, (f y, F y) ∈ u) : Continuous f :=
continuousOn_univ.mp <|
continuousOn_of_uniform_approx_of_continuousOn <| by
simpa [continuousOn_univ] using L
/-! | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | continuous_of_uniform_approx_of_continuous | A function which can be uniformly approximated by continuous functions is continuous. |
protected TendstoLocallyUniformlyOn.continuousOn (h : TendstoLocallyUniformlyOn F f p s)
(hc : ∀ᶠ n in p, ContinuousOn (F n) s) [NeBot p] : ContinuousOn f s := by
refine continuousOn_of_locally_uniform_approx_of_continuousWithinAt fun x hx u hu => ?_
rcases h u hu x hx with ⟨t, ht, H⟩
rcases (hc.and H).exists with ⟨n, hFc, hF⟩
exact ⟨t, ht, ⟨F n, hFc.continuousWithinAt hx, hF⟩⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoLocallyUniformlyOn.continuousOn | A locally uniform limit on a set of functions which are continuous on this set is itself
continuous on this set. |
protected TendstoUniformlyOn.continuousOn (h : TendstoUniformlyOn F f p s)
(hc : ∀ᶠ n in p, ContinuousOn (F n) s) [NeBot p] : ContinuousOn f s :=
h.tendstoLocallyUniformlyOn.continuousOn hc | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoUniformlyOn.continuousOn | A uniform limit on a set of functions which are continuous on this set is itself continuous
on this set. |
protected TendstoLocallyUniformly.continuous (h : TendstoLocallyUniformly F f p)
(hc : ∀ᶠ n in p, Continuous (F n)) [NeBot p] : Continuous f :=
continuousOn_univ.mp <|
h.tendstoLocallyUniformlyOn.continuousOn <| hc.mono fun _n hn => hn.continuousOn | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoLocallyUniformly.continuous | A locally uniform limit of continuous functions is continuous. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.