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 ⌀ |
|---|---|---|---|---|---|---|
protected TendstoUniformly.continuous (h : TendstoUniformly F f p)
(hc : ∀ᶠ n in p, Continuous (F n)) [NeBot p] : Continuous f :=
h.tendstoLocallyUniformly.continuous hc
/-! | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoUniformly.continuous | A uniform limit of continuous functions is continuous. |
tendsto_comp_of_locally_uniform_limit_within (h : ContinuousWithinAt f s x)
(hg : Tendsto g p (𝓝[s] x))
(hunif : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝[s] x, ∀ᶠ n in p, ∀ y ∈ t, (f y, F n y) ∈ u) :
Tendsto (fun n => F n (g n)) p (𝓝 (f x)) := by
refine Uniform.tendsto_nhds_right.2 fun u₀ hu₀ => ?_
obtain ⟨u₁, h₁, u₁₀⟩ : ∃ u ∈ 𝓤 β, u ○ u ⊆ u₀ := comp_mem_uniformity_sets hu₀
rcases hunif u₁ h₁ with ⟨s, sx, hs⟩
have A : ∀ᶠ n in p, g n ∈ s := hg sx
have B : ∀ᶠ n in p, (f x, f (g n)) ∈ u₁ := hg (Uniform.continuousWithinAt_iff'_right.1 h h₁)
exact B.mp <| A.mp <| hs.mono fun y H1 H2 H3 => u₁₀ (prodMk_mem_compRel H3 (H1 _ H2)) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | tendsto_comp_of_locally_uniform_limit_within | If `Fₙ` converges locally uniformly on a neighborhood of `x` within a set `s` to a function `f`
which is continuous at `x` within `s`, and `gₙ` tends to `x` within `s`, then `Fₙ (gₙ)` tends
to `f x`. |
tendsto_comp_of_locally_uniform_limit (h : ContinuousAt f x) (hg : Tendsto g p (𝓝 x))
(hunif : ∀ u ∈ 𝓤 β, ∃ t ∈ 𝓝 x, ∀ᶠ n in p, ∀ y ∈ t, (f y, F n y) ∈ u) :
Tendsto (fun n => F n (g n)) p (𝓝 (f x)) := by
rw [← continuousWithinAt_univ] at h
rw [← nhdsWithin_univ] at hunif hg
exact tendsto_comp_of_locally_uniform_limit_within h hg hunif | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | tendsto_comp_of_locally_uniform_limit | If `Fₙ` converges locally uniformly on a neighborhood of `x` to a function `f` which is
continuous at `x`, and `gₙ` tends to `x`, then `Fₙ (gₙ)` tends to `f x`. |
TendstoLocallyUniformlyOn.tendsto_comp (h : TendstoLocallyUniformlyOn F f p s)
(hf : ContinuousWithinAt f s x) (hx : x ∈ s) (hg : Tendsto g p (𝓝[s] x)) :
Tendsto (fun n => F n (g n)) p (𝓝 (f x)) :=
tendsto_comp_of_locally_uniform_limit_within hf hg fun u hu => h u hu x hx | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoLocallyUniformlyOn.tendsto_comp | If `Fₙ` tends locally uniformly to `f` on a set `s`, and `gₙ` tends to `x` within `s`, then
`Fₙ gₙ` tends to `f x` if `f` is continuous at `x` within `s` and `x ∈ s`. |
TendstoUniformlyOn.tendsto_comp (h : TendstoUniformlyOn F f p s)
(hf : ContinuousWithinAt f s x) (hg : Tendsto g p (𝓝[s] x)) :
Tendsto (fun n => F n (g n)) p (𝓝 (f x)) :=
tendsto_comp_of_locally_uniform_limit_within hf hg fun u hu => ⟨s, self_mem_nhdsWithin, h u hu⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoUniformlyOn.tendsto_comp | If `Fₙ` tends uniformly to `f` on a set `s`, and `gₙ` tends to `x` within `s`, then `Fₙ gₙ`
tends to `f x` if `f` is continuous at `x` within `s`. |
TendstoLocallyUniformly.tendsto_comp (h : TendstoLocallyUniformly F f p)
(hf : ContinuousAt f x) (hg : Tendsto g p (𝓝 x)) : Tendsto (fun n => F n (g n)) p (𝓝 (f x)) :=
tendsto_comp_of_locally_uniform_limit hf hg fun u hu => h u hu x | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoLocallyUniformly.tendsto_comp | If `Fₙ` tends locally uniformly to `f`, and `gₙ` tends to `x`, then `Fₙ gₙ` tends to `f x`. |
TendstoUniformly.tendsto_comp (h : TendstoUniformly F f p) (hf : ContinuousAt f x)
(hg : Tendsto g p (𝓝 x)) : Tendsto (fun n => F n (g n)) p (𝓝 (f x)) :=
h.tendstoLocallyUniformly.tendsto_comp hf hg | theorem | Topology | [
"Mathlib.Topology.UniformSpace.LocallyUniformConvergence"
] | Mathlib/Topology/UniformSpace/UniformApproximation.lean | TendstoUniformly.tendsto_comp | If `Fₙ` tends uniformly to `f`, and `gₙ` tends to `x`, then `Fₙ gₙ` tends to `f x`. |
TendstoUniformlyOnFilter (F : ι → α → β) (f : α → β) (p : Filter ι) (p' : Filter α) :=
∀ u ∈ 𝓤 β, ∀ᶠ n : ι × α in p ×ˢ p', (f n.snd, F n.fst n.snd) ∈ u | def | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter | A sequence of functions `Fₙ` converges uniformly on a filter `p'` to a limiting function `f`
with respect to the filter `p` if, for any entourage of the diagonal `u`, one has
`p ×ˢ p'`-eventually `(f x, Fₙ x) ∈ u`. |
tendstoUniformlyOnFilter_iff_tendsto :
TendstoUniformlyOnFilter F f p p' ↔
Tendsto (fun q : ι × α => (f q.2, F q.1 q.2)) (p ×ˢ p') (𝓤 β) :=
Iff.rfl | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOnFilter_iff_tendsto | A sequence of functions `Fₙ` converges uniformly on a filter `p'` to a limiting function `f` w.r.t.
filter `p` iff the function `(n, x) ↦ (f x, Fₙ x)` converges along `p ×ˢ p'` to the uniformity.
In other words: one knows nothing about the behavior of `x` in this limit besides it being in `p'`. |
TendstoUniformlyOn (F : ι → α → β) (f : α → β) (p : Filter ι) (s : Set α) :=
∀ u ∈ 𝓤 β, ∀ᶠ n in p, ∀ x : α, x ∈ s → (f x, F n x) ∈ u | def | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn | A sequence of functions `Fₙ` converges uniformly on a set `s` to a limiting function `f` with
respect to the filter `p` if, for any entourage of the diagonal `u`, one has `p`-eventually
`(f x, Fₙ x) ∈ u` for all `x ∈ s`. |
tendstoUniformlyOn_iff_tendstoUniformlyOnFilter :
TendstoUniformlyOn F f p s ↔ TendstoUniformlyOnFilter F f p (𝓟 s) := by
simp only [TendstoUniformlyOn, TendstoUniformlyOnFilter]
apply forall₂_congr
simp_rw [eventually_prod_principal_iff]
simp
alias ⟨TendstoUniformlyOn.tendstoUniformlyOnFilter, TendstoUniformlyOnFilter.tendstoUniformlyOn⟩ :=
tendstoUniformlyOn_iff_tendstoUniformlyOnFilter | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_iff_tendstoUniformlyOnFilter | null |
tendstoUniformlyOn_iff_tendsto :
TendstoUniformlyOn F f p s ↔
Tendsto (fun q : ι × α => (f q.2, F q.1 q.2)) (p ×ˢ 𝓟 s) (𝓤 β) := by
simp [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter, tendstoUniformlyOnFilter_iff_tendsto] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_iff_tendsto | A sequence of functions `Fₙ` converges uniformly on a set `s` to a limiting function `f` w.r.t.
filter `p` iff the function `(n, x) ↦ (f x, Fₙ x)` converges along `p ×ˢ 𝓟 s` to the uniformity.
In other words: one knows nothing about the behavior of `x` in this limit besides it being in `s`. |
TendstoUniformly (F : ι → α → β) (f : α → β) (p : Filter ι) :=
∀ u ∈ 𝓤 β, ∀ᶠ n in p, ∀ x : α, (f x, F n x) ∈ u | def | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly | A sequence of functions `Fₙ` converges uniformly to a limiting function `f` with respect to a
filter `p` if, for any entourage of the diagonal `u`, one has `p`-eventually
`(f x, Fₙ x) ∈ u` for all `x`. |
tendstoUniformlyOn_univ : TendstoUniformlyOn F f p univ ↔ TendstoUniformly F f p := by
simp [TendstoUniformlyOn, TendstoUniformly] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_univ | null |
tendstoUniformly_iff_tendstoUniformlyOnFilter :
TendstoUniformly F f p ↔ TendstoUniformlyOnFilter F f p ⊤ := by
rw [← tendstoUniformlyOn_univ, tendstoUniformlyOn_iff_tendstoUniformlyOnFilter, principal_univ] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformly_iff_tendstoUniformlyOnFilter | null |
TendstoUniformly.tendstoUniformlyOnFilter (h : TendstoUniformly F f p) :
TendstoUniformlyOnFilter F f p ⊤ := by rwa [← tendstoUniformly_iff_tendstoUniformlyOnFilter] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly.tendstoUniformlyOnFilter | null |
tendstoUniformlyOn_iff_tendstoUniformly_comp_coe :
TendstoUniformlyOn F f p s ↔ TendstoUniformly (fun i (x : s) => F i x) (f ∘ (↑)) p :=
forall₂_congr fun u _ => by simp | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_iff_tendstoUniformly_comp_coe | null |
tendstoUniformlyOn_iff_restrict {K : Set α} : TendstoUniformlyOn F f p K ↔
TendstoUniformly (fun n : ι => K.restrict (F n)) (K.restrict f) p :=
tendstoUniformlyOn_iff_tendstoUniformly_comp_coe | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_iff_restrict | null |
tendstoUniformly_iff_tendsto :
TendstoUniformly F f p ↔ Tendsto (fun q : ι × α => (f q.2, F q.1 q.2)) (p ×ˢ ⊤) (𝓤 β) := by
simp [tendstoUniformly_iff_tendstoUniformlyOnFilter, tendstoUniformlyOnFilter_iff_tendsto] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformly_iff_tendsto | A sequence of functions `Fₙ` converges uniformly to a limiting function `f` w.r.t.
filter `p` iff the function `(n, x) ↦ (f x, Fₙ x)` converges along `p ×ˢ ⊤` to the uniformity.
In other words: one knows nothing about the behavior of `x` in this limit. |
TendstoUniformlyOnFilter.tendsto_at (h : TendstoUniformlyOnFilter F f p p')
(hx : 𝓟 {x} ≤ p') : Tendsto (fun n => F n x) p <| 𝓝 (f x) := by
refine Uniform.tendsto_nhds_right.mpr fun u hu => mem_map.mpr ?_
filter_upwards [(h u hu).curry]
intro i h
simpa using h.filter_mono hx | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.tendsto_at | Uniform convergence implies pointwise convergence. |
TendstoUniformlyOn.tendsto_at (h : TendstoUniformlyOn F f p s) (hx : x ∈ s) :
Tendsto (fun n => F n x) p <| 𝓝 (f x) :=
h.tendstoUniformlyOnFilter.tendsto_at
(le_principal_iff.mpr <| mem_principal.mpr <| singleton_subset_iff.mpr <| hx) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.tendsto_at | Uniform convergence implies pointwise convergence. |
TendstoUniformly.tendsto_at (h : TendstoUniformly F f p) (x : α) :
Tendsto (fun n => F n x) p <| 𝓝 (f x) :=
h.tendstoUniformlyOnFilter.tendsto_at le_top | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly.tendsto_at | Uniform convergence implies pointwise convergence. |
TendstoUniformlyOnFilter.mono_left {p'' : Filter ι} (h : TendstoUniformlyOnFilter F f p p')
(hp : p'' ≤ p) : TendstoUniformlyOnFilter F f p'' p' := fun u hu =>
(h u hu).filter_mono (p'.prod_mono_left hp) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.mono_left | null |
TendstoUniformlyOnFilter.mono_right {p'' : Filter α} (h : TendstoUniformlyOnFilter F f p p')
(hp : p'' ≤ p') : TendstoUniformlyOnFilter F f p p'' := fun u hu =>
(h u hu).filter_mono (p.prod_mono_right hp) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.mono_right | null |
TendstoUniformlyOn.mono (h : TendstoUniformlyOn F f p s) (h' : s' ⊆ s) :
TendstoUniformlyOn F f p s' :=
tendstoUniformlyOn_iff_tendstoUniformlyOnFilter.mpr
(h.tendstoUniformlyOnFilter.mono_right (le_principal_iff.mpr <| mem_principal.mpr h')) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.mono | null |
TendstoUniformlyOnFilter.congr {F' : ι → α → β} (hf : TendstoUniformlyOnFilter F f p p')
(hff' : ∀ᶠ n : ι × α in p ×ˢ p', F n.fst n.snd = F' n.fst n.snd) :
TendstoUniformlyOnFilter F' f p p' := by
refine fun u hu => ((hf u hu).and hff').mono fun n h => ?_
rw [← h.right]
exact h.left | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.congr | null |
TendstoUniformlyOn.congr {F' : ι → α → β} (hf : TendstoUniformlyOn F f p s)
(hff' : ∀ᶠ n in p, Set.EqOn (F n) (F' n) s) : TendstoUniformlyOn F' f p s := by
rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter] at hf ⊢
refine hf.congr ?_
rw [eventually_iff] at hff' ⊢
simp only [Set.EqOn] at hff'
simp only [mem_prod_principal, hff', mem_setOf_eq] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.congr | null |
tendstoUniformly_congr {F' : ι → α → β} (hF : F =ᶠ[p] F') :
TendstoUniformly F f p ↔ TendstoUniformly F' f p := by
simp_rw [← tendstoUniformlyOn_univ] at *
have HF := EventuallyEq.exists_mem hF
exact ⟨fun h => h.congr (by aesop), fun h => h.congr (by simp_rw [eqOn_comm]; aesop)⟩ | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformly_congr | null |
TendstoUniformlyOn.congr_right {g : α → β} (hf : TendstoUniformlyOn F f p s)
(hfg : EqOn f g s) : TendstoUniformlyOn F g p s := fun u hu => by
filter_upwards [hf u hu] with i hi a ha using hfg ha ▸ hi a ha | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.congr_right | null |
protected TendstoUniformly.tendstoUniformlyOn (h : TendstoUniformly F f p) :
TendstoUniformlyOn F f p s :=
(tendstoUniformlyOn_univ.2 h).mono (subset_univ s) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly.tendstoUniformlyOn | null |
TendstoUniformlyOnFilter.comp (h : TendstoUniformlyOnFilter F f p p') (g : γ → α) :
TendstoUniformlyOnFilter (fun n => F n ∘ g) (f ∘ g) p (p'.comap g) := by
rw [tendstoUniformlyOnFilter_iff_tendsto] at h ⊢
exact h.comp (tendsto_id.prodMap tendsto_comap) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.comp | Composing on the right by a function preserves uniform convergence on a filter |
TendstoUniformlyOn.comp (h : TendstoUniformlyOn F f p s) (g : γ → α) :
TendstoUniformlyOn (fun n => F n ∘ g) (f ∘ g) p (g ⁻¹' s) := by
rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter] at h ⊢
simpa [TendstoUniformlyOn, comap_principal] using TendstoUniformlyOnFilter.comp h g | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.comp | Composing on the right by a function preserves uniform convergence on a set |
TendstoUniformly.comp (h : TendstoUniformly F f p) (g : γ → α) :
TendstoUniformly (fun n => F n ∘ g) (f ∘ g) p := by
rw [tendstoUniformly_iff_tendstoUniformlyOnFilter] at h ⊢
simpa [principal_univ, comap_principal] using h.comp g | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly.comp | Composing on the right by a function preserves uniform convergence |
UniformContinuous.comp_tendstoUniformlyOnFilter [UniformSpace γ] {g : β → γ}
(hg : UniformContinuous g) (h : TendstoUniformlyOnFilter F f p p') :
TendstoUniformlyOnFilter (fun i => g ∘ F i) (g ∘ f) p p' := fun _u hu => h _ (hg hu) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformContinuous.comp_tendstoUniformlyOnFilter | Composing on the left by a uniformly continuous function preserves
uniform convergence on a filter |
UniformContinuous.comp_tendstoUniformlyOn [UniformSpace γ] {g : β → γ}
(hg : UniformContinuous g) (h : TendstoUniformlyOn F f p s) :
TendstoUniformlyOn (fun i => g ∘ F i) (g ∘ f) p s := fun _u hu => h _ (hg hu) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformContinuous.comp_tendstoUniformlyOn | Composing on the left by a uniformly continuous function preserves
uniform convergence on a set |
UniformContinuous.comp_tendstoUniformly [UniformSpace γ] {g : β → γ}
(hg : UniformContinuous g) (h : TendstoUniformly F f p) :
TendstoUniformly (fun i => g ∘ F i) (g ∘ f) p := fun _u hu => h _ (hg hu) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformContinuous.comp_tendstoUniformly | Composing on the left by a uniformly continuous function preserves uniform convergence |
TendstoUniformlyOnFilter.prodMap {ι' α' β' : Type*} [UniformSpace β'] {F' : ι' → α' → β'}
{f' : α' → β'} {q : Filter ι'} {q' : Filter α'} (h : TendstoUniformlyOnFilter F f p p')
(h' : TendstoUniformlyOnFilter F' f' q q') :
TendstoUniformlyOnFilter (fun i : ι × ι' => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ q)
(p' ×ˢ q') := by
rw [tendstoUniformlyOnFilter_iff_tendsto] at h h' ⊢
rw [uniformity_prod_eq_comap_prod, tendsto_comap_iff, ← map_swap4_prod, tendsto_map'_iff]
simpa using h.prodMap h'
@[deprecated (since := "2025-03-10")]
alias TendstoUniformlyOnFilter.prod_map := TendstoUniformlyOnFilter.prodMap | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.prodMap | null |
TendstoUniformlyOn.prodMap {ι' α' β' : Type*} [UniformSpace β'] {F' : ι' → α' → β'}
{f' : α' → β'} {p' : Filter ι'} {s' : Set α'} (h : TendstoUniformlyOn F f p s)
(h' : TendstoUniformlyOn F' f' p' s') :
TendstoUniformlyOn (fun i : ι × ι' => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p')
(s ×ˢ s') := by
rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter] at h h' ⊢
simpa only [prod_principal_principal] using h.prodMap h'
@[deprecated (since := "2025-03-10")]
alias TendstoUniformlyOn.prod_map := TendstoUniformlyOn.prodMap | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.prodMap | null |
TendstoUniformly.prodMap {ι' α' β' : Type*} [UniformSpace β'] {F' : ι' → α' → β'}
{f' : α' → β'} {p' : Filter ι'} (h : TendstoUniformly F f p) (h' : TendstoUniformly F' f' p') :
TendstoUniformly (fun i : ι × ι' => Prod.map (F i.1) (F' i.2)) (Prod.map f f') (p ×ˢ p') := by
rw [← tendstoUniformlyOn_univ, ← univ_prod_univ] at *
exact h.prodMap h'
@[deprecated (since := "2025-03-10")]
alias TendstoUniformly.prod_map := TendstoUniformly.prodMap | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly.prodMap | null |
TendstoUniformlyOnFilter.prodMk {ι' β' : Type*} [UniformSpace β'] {F' : ι' → α → β'}
{f' : α → β'} {q : Filter ι'} (h : TendstoUniformlyOnFilter F f p p')
(h' : TendstoUniformlyOnFilter F' f' q p') :
TendstoUniformlyOnFilter (fun (i : ι × ι') a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a))
(p ×ˢ q) p' :=
fun u hu => ((h.prodMap h') u hu).diag_of_prod_right
@[deprecated (since := "2025-03-10")]
alias TendstoUniformlyOnFilter.prod := TendstoUniformlyOnFilter.prodMk | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.prodMk | null |
protected TendstoUniformlyOn.prodMk {ι' β' : Type*} [UniformSpace β'] {F' : ι' → α → β'}
{f' : α → β'} {p' : Filter ι'} (h : TendstoUniformlyOn F f p s)
(h' : TendstoUniformlyOn F' f' p' s) :
TendstoUniformlyOn (fun (i : ι × ι') a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a)) (p ×ˢ p')
s :=
(congr_arg _ s.inter_self).mp ((h.prodMap h').comp fun a => (a, a))
@[deprecated (since := "2025-03-10")]
alias TendstoUniformlyOn.prod := TendstoUniformlyOn.prodMk | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.prodMk | null |
TendstoUniformly.prodMk {ι' β' : Type*} [UniformSpace β'] {F' : ι' → α → β'} {f' : α → β'}
{p' : Filter ι'} (h : TendstoUniformly F f p) (h' : TendstoUniformly F' f' p') :
TendstoUniformly (fun (i : ι × ι') a => (F i.1 a, F' i.2 a)) (fun a => (f a, f' a)) (p ×ˢ p') :=
(h.prodMap h').comp fun a => (a, a)
@[deprecated (since := "2025-03-10")]
alias TendstoUniformly.prod := TendstoUniformly.prodMk | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly.prodMk | null |
tendsto_prod_filter_iff {c : β} :
Tendsto ↿F (p ×ˢ p') (𝓝 c) ↔ TendstoUniformlyOnFilter F (fun _ => c) p p' := by
simp_rw [nhds_eq_comap_uniformity, tendsto_comap_iff]
rfl | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendsto_prod_filter_iff | Uniform convergence on a filter `p'` to a constant function is equivalent to convergence in
`p ×ˢ p'`. |
tendsto_prod_principal_iff {c : β} :
Tendsto ↿F (p ×ˢ 𝓟 s) (𝓝 c) ↔ TendstoUniformlyOn F (fun _ => c) p s := by
rw [tendstoUniformlyOn_iff_tendstoUniformlyOnFilter]
exact tendsto_prod_filter_iff | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendsto_prod_principal_iff | Uniform convergence on a set `s` to a constant function is equivalent to convergence in
`p ×ˢ 𝓟 s`. |
tendsto_prod_top_iff {c : β} :
Tendsto ↿F (p ×ˢ ⊤) (𝓝 c) ↔ TendstoUniformly F (fun _ => c) p := by
rw [tendstoUniformly_iff_tendstoUniformlyOnFilter]
exact tendsto_prod_filter_iff | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendsto_prod_top_iff | Uniform convergence to a constant function is equivalent to convergence in `p ×ˢ ⊤`. |
tendstoUniformlyOn_empty : TendstoUniformlyOn F f p ∅ := fun u _ => by simp | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_empty | Uniform convergence on the empty set is vacuously true |
tendstoUniformlyOn_singleton_iff_tendsto :
TendstoUniformlyOn F f p {x} ↔ Tendsto (fun n : ι => F n x) p (𝓝 (f x)) := by
simp_rw [tendstoUniformlyOn_iff_tendsto, Uniform.tendsto_nhds_right, tendsto_def]
exact forall₂_congr fun u _ => by simp [preimage] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_singleton_iff_tendsto | Uniform convergence on a singleton is equivalent to regular convergence |
Filter.Tendsto.tendstoUniformlyOnFilter_const {g : ι → β} {b : β} (hg : Tendsto g p (𝓝 b))
(p' : Filter α) :
TendstoUniformlyOnFilter (fun n : ι => fun _ : α => g n) (fun _ : α => b) p p' := by
simpa only [nhds_eq_comap_uniformity, tendsto_comap_iff] using hg.comp (tendsto_fst (g := p')) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | Filter.Tendsto.tendstoUniformlyOnFilter_const | If a sequence `g` converges to some `b`, then the sequence of constant functions
`fun n ↦ fun a ↦ g n` converges to the constant function `fun a ↦ b` on any set `s` |
Filter.Tendsto.tendstoUniformlyOn_const {g : ι → β} {b : β} (hg : Tendsto g p (𝓝 b))
(s : Set α) : TendstoUniformlyOn (fun n : ι => fun _ : α => g n) (fun _ : α => b) p s :=
tendstoUniformlyOn_iff_tendstoUniformlyOnFilter.mpr (hg.tendstoUniformlyOnFilter_const (𝓟 s)) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | Filter.Tendsto.tendstoUniformlyOn_const | If a sequence `g` converges to some `b`, then the sequence of constant functions
`fun n ↦ fun a ↦ g n` converges to the constant function `fun a ↦ b` on any set `s` |
UniformContinuousOn.tendstoUniformlyOn [UniformSpace α] [UniformSpace γ] {U : Set α}
{V : Set β} {F : α → β → γ} (hF : UniformContinuousOn ↿F (U ×ˢ V)) (hU : x ∈ U) :
TendstoUniformlyOn F (F x) (𝓝[U] x) V := by
set φ := fun q : α × β => ((x, q.2), q)
rw [tendstoUniformlyOn_iff_tendsto]
change Tendsto (Prod.map ↿F ↿F ∘ φ) (𝓝[U] x ×ˢ 𝓟 V) (𝓤 γ)
simp only [nhdsWithin, Filter.prod_eq_inf, comap_inf, inf_assoc, comap_principal, inf_principal]
refine hF.comp (Tendsto.inf ?_ <| tendsto_principal_principal.2 fun x hx => ⟨⟨hU, hx.2⟩, hx⟩)
simp only [uniformity_prod_eq_comap_prod, tendsto_comap_iff,
nhds_eq_comap_uniformity, comap_comap]
exact tendsto_comap.prodMk (tendsto_diag_uniformity _ _) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformContinuousOn.tendstoUniformlyOn | null |
UniformContinuousOn.tendstoUniformly [UniformSpace α] [UniformSpace γ] {U : Set α}
(hU : U ∈ 𝓝 x) {F : α → β → γ} (hF : UniformContinuousOn ↿F (U ×ˢ (univ : Set β))) :
TendstoUniformly F (F x) (𝓝 x) := by
simpa only [tendstoUniformlyOn_univ, nhdsWithin_eq_nhds.2 hU]
using hF.tendstoUniformlyOn (mem_of_mem_nhds hU) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformContinuousOn.tendstoUniformly | null |
UniformContinuous₂.tendstoUniformly [UniformSpace α] [UniformSpace γ] {f : α → β → γ}
(h : UniformContinuous₂ f) : TendstoUniformly f (f x) (𝓝 x) :=
UniformContinuousOn.tendstoUniformly univ_mem <| by rwa [univ_prod_univ, uniformContinuousOn_univ] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformContinuous₂.tendstoUniformly | null |
tendstoUniformlyOnFilter_iff_of_uniformity {F : X → α → β} {f : α → β}
{l : Filter X} {l' : Filter α} {pβ : ιβ → Prop} {sβ : ιβ → Set (β × β)}
(hβ : (uniformity β).HasBasis pβ sβ) :
TendstoUniformlyOnFilter F f l l' ↔
(∀ i, pβ i → ∀ᶠ n in l ×ˢ l', (f n.2, F n.1 n.2) ∈ sβ i) := by
rw [tendstoUniformlyOnFilter_iff_tendsto, hβ.tendsto_right_iff] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOnFilter_iff_of_uniformity | An analogue of `Filter.HasBasis.tendsto_right_iff` for `TendstoUniformlyOnFilter`. |
tendstoUniformlyOnFilter_iff {F : X → α → β} {f : α → β}
{l : Filter X} {l' : Filter α} {pX : ιX → Prop} {sX : ιX → Set X}
{pα : ια → Prop} {sα : ια → Set α} {pβ : ιβ → Prop} {sβ : ιβ → Set (β × β)}
(hl : l.HasBasis pX sX) (hl' : l'.HasBasis pα sα)
(hβ : (uniformity β).HasBasis pβ sβ) :
TendstoUniformlyOnFilter F f l l' ↔
(∀ i, pβ i → ∃ j k, (pX j ∧ pα k) ∧ ∀ x a, x ∈ sX j → a ∈ sα k → (f a, F x a) ∈ sβ i) := by
simp [hβ.tendstoUniformlyOnFilter_iff_of_uniformity, (hl.prod hl').eventually_iff] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOnFilter_iff | An analogue of `Filter.HasBasis.tendsto_iff` for `TendstoUniformlyOnFilter`. |
tendstoUniformlyOn_iff_of_uniformity {F : X → α → β} {f : α → β}
{l : Filter X} {s : Set α} {pβ : ιβ → Prop} {sβ : ιβ → Set (β × β)}
(hβ : (uniformity β).HasBasis pβ sβ) :
TendstoUniformlyOn F f l s ↔
(∀ i, pβ i → ∀ᶠ n in l, ∀ x ∈ s, (f x, F n x) ∈ sβ i) := by
simp_rw [tendstoUniformlyOn_iff_tendsto, hβ.tendsto_right_iff, eventually_prod_principal_iff] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_iff_of_uniformity | An analogue of `Filter.HasBasis.tendsto_right_iff` for `TendstoUniformlyOn`. |
tendstoUniformlyOn_iff {F : X → α → β} {f : α → β}
{l : Filter X} {s : Set α} {pX : ιX → Prop} {sX : ιX → Set X} {pβ : ιβ → Prop}
{sβ : ιβ → Set (β × β)} (hl : l.HasBasis pX sX) (hβ : (uniformity β).HasBasis pβ sβ) :
TendstoUniformlyOn F f l s ↔
(∀ i, pβ i → ∃ j, pX j ∧ ∀ ⦃x⦄, x ∈ sX j → ∀ a ∈ s, (f a, F x a) ∈ sβ i) := by
simp [hβ.tendstoUniformlyOn_iff_of_uniformity, hl.eventually_iff] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_iff | An analogue of `Filter.HasBasis.tendsto_iff` for `TendstoUniformlyOn`. |
tendstoUniformly_iff_of_uniformity {F : X → α → β} {f : α → β}
{l : Filter X} {pβ : ιβ → Prop} {sβ : ιβ → Set (β × β)}
(hβ : (uniformity β).HasBasis pβ sβ) :
TendstoUniformly F f l ↔
(∀ i, pβ i → ∀ᶠ n in l, ∀ x, (f x, F n x) ∈ sβ i) := by
simp_rw [← tendstoUniformlyOn_univ, hβ.tendstoUniformlyOn_iff_of_uniformity, mem_univ,
true_imp_iff] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformly_iff_of_uniformity | An analogue of `Filter.HasBasis.tendsto_right_iff` for `TendstoUniformly`. |
tendstoUniformly_iff {F : X → α → β} {f : α → β}
{l : Filter X} {pX : ιX → Prop} {sX : ιX → Set X} (hl : l.HasBasis pX sX)
{pβ : ιβ → Prop} {sβ : ιβ → Set (β × β)} (hβ : (uniformity β).HasBasis pβ sβ) :
TendstoUniformly F f l ↔
(∀ i, pβ i → ∃ j, pX j ∧ ∀ ⦃x⦄, x ∈ sX j → ∀ a, (f a, F x a) ∈ sβ i) := by
simp only [hβ.tendstoUniformly_iff_of_uniformity, hl.eventually_iff] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformly_iff | An analogue of `Filter.HasBasis.tendsto_iff` for `TendstoUniformly`. |
UniformCauchySeqOnFilter (F : ι → α → β) (p : Filter ι) (p' : Filter α) : Prop :=
∀ u ∈ 𝓤 β, ∀ᶠ m : (ι × ι) × α in (p ×ˢ p) ×ˢ p', (F m.fst.fst m.snd, F m.fst.snd m.snd) ∈ u | def | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOnFilter | A sequence is uniformly Cauchy if eventually all of its pairwise differences are
uniformly bounded |
UniformCauchySeqOn (F : ι → α → β) (p : Filter ι) (s : Set α) : Prop :=
∀ u ∈ 𝓤 β, ∀ᶠ m : ι × ι in p ×ˢ p, ∀ x : α, x ∈ s → (F m.fst x, F m.snd x) ∈ u | def | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn | A sequence is uniformly Cauchy if eventually all of its pairwise differences are
uniformly bounded |
uniformCauchySeqOn_iff_uniformCauchySeqOnFilter :
UniformCauchySeqOn F p s ↔ UniformCauchySeqOnFilter F p (𝓟 s) := by
simp only [UniformCauchySeqOn, UniformCauchySeqOnFilter]
refine forall₂_congr fun u hu => ?_
rw [eventually_prod_principal_iff] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | uniformCauchySeqOn_iff_uniformCauchySeqOnFilter | null |
UniformCauchySeqOn.uniformCauchySeqOnFilter (hF : UniformCauchySeqOn F p s) :
UniformCauchySeqOnFilter F p (𝓟 s) := by rwa [← uniformCauchySeqOn_iff_uniformCauchySeqOnFilter] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.uniformCauchySeqOnFilter | null |
TendstoUniformlyOnFilter.uniformCauchySeqOnFilter (hF : TendstoUniformlyOnFilter F f p p') :
UniformCauchySeqOnFilter F p p' := by
intro u hu
rcases comp_symm_of_uniformity hu with ⟨t, ht, htsymm, htmem⟩
have := tendsto_swap4_prod.eventually ((hF t ht).prod_mk (hF t ht))
apply this.diag_of_prod_right.mono
simp only [and_imp, Prod.forall]
intro n1 n2 x hl hr
exact Set.mem_of_mem_of_subset (prodMk_mem_compRel (htsymm hl) hr) htmem | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.uniformCauchySeqOnFilter | A sequence that converges uniformly is also uniformly Cauchy |
TendstoUniformlyOn.uniformCauchySeqOn (hF : TendstoUniformlyOn F f p s) :
UniformCauchySeqOn F p s :=
uniformCauchySeqOn_iff_uniformCauchySeqOnFilter.mpr
hF.tendstoUniformlyOnFilter.uniformCauchySeqOnFilter | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.uniformCauchySeqOn | A sequence that converges uniformly is also uniformly Cauchy |
UniformCauchySeqOnFilter.tendstoUniformlyOnFilter_of_tendsto
(hF : UniformCauchySeqOnFilter F p p')
(hF' : ∀ᶠ x : α in p', Tendsto (fun n => F n x) p (𝓝 (f x))) :
TendstoUniformlyOnFilter F f p p' := by
rcases p.eq_or_neBot with rfl | _
· simp only [TendstoUniformlyOnFilter, bot_prod, eventually_bot, implies_true]
intro u hu
rcases comp_symm_of_uniformity hu with ⟨t, ht, htsymm, htmem⟩
have hmc : ∀ᶠ x in (p ×ˢ p) ×ˢ p', Tendsto (fun n : ι => F n x.snd) p (𝓝 (f x.snd)) := by
rw [eventually_prod_iff]
exact ⟨fun _ => True, by simp, _, hF', by simp⟩
rw [Filter.eventually_swap_iff]
have := tendsto_prodAssoc.eventually (tendsto_prod_swap.eventually ((hF t ht).and hmc))
apply this.curry.mono
simp only [Equiv.prodAssoc_apply, eventually_and, eventually_const, Prod.snd_swap, Prod.fst_swap,
and_imp, Prod.forall]
intro x n hx hm'
refine Set.mem_of_mem_of_subset (mem_compRel.mpr ?_) htmem
rw [Uniform.tendsto_nhds_right] at hm'
have := hx.and (hm' ht)
obtain ⟨m, hm⟩ := this.exists
exact ⟨F m x, ⟨hm.2, htsymm hm.1⟩⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOnFilter.tendstoUniformlyOnFilter_of_tendsto | A uniformly Cauchy sequence converges uniformly to its limit |
UniformCauchySeqOn.tendstoUniformlyOn_of_tendsto (hF : UniformCauchySeqOn F p s)
(hF' : ∀ x : α, x ∈ s → Tendsto (fun n => F n x) p (𝓝 (f x))) : TendstoUniformlyOn F f p s :=
tendstoUniformlyOn_iff_tendstoUniformlyOnFilter.mpr
(hF.uniformCauchySeqOnFilter.tendstoUniformlyOnFilter_of_tendsto hF') | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.tendstoUniformlyOn_of_tendsto | A uniformly Cauchy sequence converges uniformly to its limit |
UniformCauchySeqOnFilter.mono_left {p'' : Filter ι} (hf : UniformCauchySeqOnFilter F p p')
(hp : p'' ≤ p) : UniformCauchySeqOnFilter F p'' p' := fun u hu =>
(hf u hu).filter_mono (p'.prod_mono_left (Filter.prod_mono hp hp)) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOnFilter.mono_left | null |
UniformCauchySeqOnFilter.mono_right {p'' : Filter α} (hf : UniformCauchySeqOnFilter F p p')
(hp : p'' ≤ p') : UniformCauchySeqOnFilter F p p'' := fun u hu =>
have := (hf u hu).filter_mono ((p ×ˢ p).prod_mono_right hp)
this.mono (by simp) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOnFilter.mono_right | null |
UniformCauchySeqOn.mono (hf : UniformCauchySeqOn F p s) (hss' : s' ⊆ s) :
UniformCauchySeqOn F p s' := by
rw [uniformCauchySeqOn_iff_uniformCauchySeqOnFilter] at hf ⊢
exact hf.mono_right (le_principal_iff.mpr <| mem_principal.mpr hss') | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.mono | null |
UniformCauchySeqOnFilter.comp {γ : Type*} (hf : UniformCauchySeqOnFilter F p p')
(g : γ → α) : UniformCauchySeqOnFilter (fun n => F n ∘ g) p (p'.comap g) := fun u hu => by
obtain ⟨pa, hpa, pb, hpb, hpapb⟩ := eventually_prod_iff.mp (hf u hu)
rw [eventually_prod_iff]
refine ⟨pa, hpa, pb ∘ g, ?_, fun hx _ hy => hpapb hx hy⟩
exact eventually_comap.mpr (hpb.mono fun x hx y hy => by simp only [hx, hy, Function.comp_apply]) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOnFilter.comp | Composing on the right by a function preserves uniform Cauchy sequences |
UniformCauchySeqOn.comp {γ : Type*} (hf : UniformCauchySeqOn F p s) (g : γ → α) :
UniformCauchySeqOn (fun n => F n ∘ g) p (g ⁻¹' s) := by
rw [uniformCauchySeqOn_iff_uniformCauchySeqOnFilter] at hf ⊢
simpa only [UniformCauchySeqOn, comap_principal] using hf.comp g | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.comp | Composing on the right by a function preserves uniform Cauchy sequences |
UniformContinuous.comp_uniformCauchySeqOn [UniformSpace γ] {g : β → γ}
(hg : UniformContinuous g) (hf : UniformCauchySeqOn F p s) :
UniformCauchySeqOn (fun n => g ∘ F n) p s := fun _u hu => hf _ (hg hu) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformContinuous.comp_uniformCauchySeqOn | Composing on the left by a uniformly continuous function preserves
uniform Cauchy sequences |
UniformCauchySeqOn.prodMap {ι' α' β' : Type*} [UniformSpace β'] {F' : ι' → α' → β'}
{p' : Filter ι'} {s' : Set α'} (h : UniformCauchySeqOn F p s)
(h' : UniformCauchySeqOn F' p' s') :
UniformCauchySeqOn (fun i : ι × ι' => Prod.map (F i.1) (F' i.2)) (p ×ˢ p') (s ×ˢ s') := by
intro u hu
rw [uniformity_prod_eq_prod, mem_map, mem_prod_iff] at hu
obtain ⟨v, hv, w, hw, hvw⟩ := hu
simp_rw [mem_prod, and_imp, Prod.forall, Prod.map_apply]
rw [← Set.image_subset_iff] at hvw
apply (tendsto_swap4_prod.eventually ((h v hv).prod_mk (h' w hw))).mono
intro x hx a b ha hb
exact hvw ⟨_, mk_mem_prod (hx.1 a ha) (hx.2 b hb), rfl⟩
@[deprecated (since := "2025-03-10")]
alias UniformCauchySeqOn.prod_map := UniformCauchySeqOn.prodMap | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.prodMap | null |
UniformCauchySeqOn.prod {ι' β' : Type*} [UniformSpace β'] {F' : ι' → α → β'}
{p' : Filter ι'} (h : UniformCauchySeqOn F p s) (h' : UniformCauchySeqOn F' p' s) :
UniformCauchySeqOn (fun (i : ι × ι') a => (F i.fst a, F' i.snd a)) (p ×ˢ p') s :=
(congr_arg _ s.inter_self).mp ((h.prodMap h').comp fun a => (a, a)) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.prod | null |
UniformCauchySeqOn.prod' {β' : Type*} [UniformSpace β'] {F' : ι → α → β'}
(h : UniformCauchySeqOn F p s) (h' : UniformCauchySeqOn F' p s) :
UniformCauchySeqOn (fun (i : ι) a => (F i a, F' i a)) p s := fun u hu =>
have hh : Tendsto (fun x : ι => (x, x)) p (p ×ˢ p) := tendsto_diag
(hh.prodMap hh).eventually ((h.prod h') u hu) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.prod' | null |
UniformCauchySeqOn.cauchy_map [hp : NeBot p] (hf : UniformCauchySeqOn F p s) (hx : x ∈ s) :
Cauchy (map (fun i => F i x) p) := by
simp only [cauchy_map_iff, hp, true_and]
intro u hu
rw [mem_map]
filter_upwards [hf u hu] with p hp using hp x hx | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.cauchy_map | If a sequence of functions is uniformly Cauchy on a set, then the values at each point form
a Cauchy sequence. |
UniformCauchySeqOn.cauchySeq [Nonempty ι] [SemilatticeSup ι]
(hf : UniformCauchySeqOn F atTop s) (hx : x ∈ s) :
CauchySeq fun i ↦ F i x :=
hf.cauchy_map (hp := atTop_neBot) hx | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | UniformCauchySeqOn.cauchySeq | If a sequence of functions is uniformly Cauchy on a set, then the values at each point form
a Cauchy sequence. See `UniformCauchySeqOn.cauchy_map` for the non-`atTop` case. |
tendstoUniformlyOn_of_seq_tendstoUniformlyOn {l : Filter ι} [l.IsCountablyGenerated]
(h : ∀ u : ℕ → ι, Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop s) :
TendstoUniformlyOn F f l s := by
rw [tendstoUniformlyOn_iff_tendsto, tendsto_iff_seq_tendsto]
intro u hu
rw [tendsto_prod_iff'] at hu
specialize h (fun n => (u n).fst) hu.1
rw [tendstoUniformlyOn_iff_tendsto] at h
exact h.comp (tendsto_id.prodMk hu.2) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_of_seq_tendstoUniformlyOn | null |
TendstoUniformlyOn.seq_tendstoUniformlyOn {l : Filter ι} (h : TendstoUniformlyOn F f l s)
(u : ℕ → ι) (hu : Tendsto u atTop l) : TendstoUniformlyOn (fun n => F (u n)) f atTop s := by
rw [tendstoUniformlyOn_iff_tendsto] at h ⊢
exact h.comp ((hu.comp tendsto_fst).prodMk tendsto_snd) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOn.seq_tendstoUniformlyOn | null |
tendstoUniformlyOn_iff_seq_tendstoUniformlyOn {l : Filter ι} [l.IsCountablyGenerated] :
TendstoUniformlyOn F f l s ↔
∀ u : ℕ → ι, Tendsto u atTop l → TendstoUniformlyOn (fun n => F (u n)) f atTop s :=
⟨TendstoUniformlyOn.seq_tendstoUniformlyOn, tendstoUniformlyOn_of_seq_tendstoUniformlyOn⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformlyOn_iff_seq_tendstoUniformlyOn | null |
tendstoUniformly_iff_seq_tendstoUniformly {l : Filter ι} [l.IsCountablyGenerated] :
TendstoUniformly F f l ↔
∀ u : ℕ → ι, Tendsto u atTop l → TendstoUniformly (fun n => F (u n)) f atTop := by
simp_rw [← tendstoUniformlyOn_univ]
exact tendstoUniformlyOn_iff_seq_tendstoUniformlyOn | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | tendstoUniformly_iff_seq_tendstoUniformly | null |
TendstoUniformlyOnFilter.tendsto_of_eventually_tendsto
(h1 : TendstoUniformlyOnFilter F f p p') (h2 : ∀ᶠ i in p, Tendsto (F i) p' (𝓝 (L i)))
(h3 : Tendsto L p (𝓝 ℓ)) : Tendsto f p' (𝓝 ℓ) := by
rw [tendsto_nhds_left]
intro s hs
rw [mem_map, Set.preimage, ← eventually_iff]
obtain ⟨t, ht, hts⟩ := comp3_mem_uniformity hs
have p1 : ∀ᶠ i in p, (L i, ℓ) ∈ t := tendsto_nhds_left.mp h3 ht
have p2 : ∀ᶠ i in p, ∀ᶠ x in p', (F i x, L i) ∈ t := by
filter_upwards [h2] with i h2 using tendsto_nhds_left.mp h2 ht
have p3 : ∀ᶠ i in p, ∀ᶠ x in p', (f x, F i x) ∈ t := (h1 t ht).curry
obtain ⟨i, p4, p5, p6⟩ := (p1.and (p2.and p3)).exists
filter_upwards [p5, p6] with x p5 p6 using hts ⟨F i x, p6, L i, p5, p4⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformlyOnFilter.tendsto_of_eventually_tendsto | null |
TendstoUniformly.tendsto_of_eventually_tendsto
(h1 : TendstoUniformly F f p) (h2 : ∀ᶠ i in p, Tendsto (F i) p' (𝓝 (L i)))
(h3 : Tendsto L p (𝓝 ℓ)) : Tendsto f p' (𝓝 ℓ) :=
(h1.tendstoUniformlyOnFilter.mono_right le_top).tendsto_of_eventually_tendsto h2 h3 | theorem | Topology | [
"Mathlib.Topology.UniformSpace.Cauchy"
] | Mathlib/Topology/UniformSpace/UniformConvergence.lean | TendstoUniformly.tendsto_of_eventually_tendsto | null |
of the uniform structure of uniform convergence! Instead, we build a
(not very interesting) Galois connection `UniformFun.gc` and then rely on the Galois
connection API to do most of the work. | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | of | null |
UniformFun (α β : Type*) :=
α → β | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | UniformFun | The type of functions from `α` to `β` equipped with the uniform structure and topology of
uniform convergence. We denote it `α →ᵤ β`. |
@[nolint unusedArguments]
UniformOnFun (α β : Type*) (_ : Set (Set α)) :=
α → β
@[inherit_doc] scoped[UniformConvergence] notation:25 α " →ᵤ " β:0 => UniformFun α β
@[inherit_doc] scoped[UniformConvergence] notation:25 α " →ᵤ[" 𝔖 "] " β:0 => UniformOnFun α β 𝔖
open UniformConvergence
variable {α β : Type*} {𝔖 : Set (Set α)} | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | UniformOnFun | The type of functions from `α` to `β` equipped with the uniform structure and topology of
uniform convergence on some family `𝔖` of subsets of `α`. We denote it `α →ᵤ[𝔖] β`. |
UniformFun.ofFun : (α → β) ≃ (α →ᵤ β) :=
⟨fun x => x, fun x => x, fun _ => rfl, fun _ => rfl⟩ | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | UniformFun.ofFun | Reinterpret `f : α → β` as an element of `α →ᵤ β`. |
UniformOnFun.ofFun (𝔖) : (α → β) ≃ (α →ᵤ[𝔖] β) :=
⟨fun x => x, fun x => x, fun _ => rfl, fun _ => rfl⟩ | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | UniformOnFun.ofFun | Reinterpret `f : α → β` as an element of `α →ᵤ[𝔖] β`. |
UniformFun.toFun : (α →ᵤ β) ≃ (α → β) :=
UniformFun.ofFun.symm | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | UniformFun.toFun | Reinterpret `f : α →ᵤ β` as an element of `α → β`. |
UniformOnFun.toFun (𝔖) : (α →ᵤ[𝔖] β) ≃ (α → β) :=
(UniformOnFun.ofFun 𝔖).symm
@[simp] lemma UniformFun.toFun_ofFun (f : α → β) : toFun (ofFun f) = f := rfl
@[simp] lemma UniformFun.ofFun_toFun (f : α →ᵤ β) : ofFun (toFun f) = f := rfl
@[simp] lemma UniformOnFun.toFun_ofFun (f : α → β) : toFun 𝔖 (ofFun 𝔖 f) = f := rfl
@[simp] lemma UniformOnFun.ofFun_toFun (f : α →ᵤ[𝔖] β) : ofFun 𝔖 (toFun 𝔖 f) = f := rfl | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | UniformOnFun.toFun | Reinterpret `f : α →ᵤ[𝔖] β` as an element of `α → β`. |
protected gen (V : Set (β × β)) : Set ((α →ᵤ β) × (α →ᵤ β)) :=
{ uv : (α →ᵤ β) × (α →ᵤ β) | ∀ x, (toFun uv.1 x, toFun uv.2 x) ∈ V } | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | gen | Basis sets for the uniformity of uniform convergence: `gen α β V` is the set of pairs `(f, g)`
of functions `α →ᵤ β` such that `∀ x, (f x, g x) ∈ V`. |
protected isBasis_gen (𝓑 : Filter <| β × β) :
IsBasis (fun V : Set (β × β) => V ∈ 𝓑) (UniformFun.gen α β) :=
⟨⟨univ, univ_mem⟩, @fun U V hU hV =>
⟨U ∩ V, inter_mem hU hV, fun _ huv => ⟨fun x => (huv x).left, fun x => (huv x).right⟩⟩⟩ | theorem | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | isBasis_gen | If `𝓕` is a filter on `β × β`, then the set of all `UniformFun.gen α β V` for
`V ∈ 𝓕` is a filter basis on `(α →ᵤ β) × (α →ᵤ β)`. This will only be applied to `𝓕 = 𝓤 β` when
`β` is equipped with a `UniformSpace` structure, but it is useful to define it for any filter in
order to be able to state that it has a lower adjoint (see `UniformFun.gc`). |
protected basis (𝓕 : Filter <| β × β) : FilterBasis ((α →ᵤ β) × (α →ᵤ β)) :=
(UniformFun.isBasis_gen α β 𝓕).filterBasis | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | basis | For `𝓕 : Filter (β × β)`, this is the set of all `UniformFun.gen α β V` for
`V ∈ 𝓕` as a bundled `FilterBasis` over `(α →ᵤ β) × (α →ᵤ β)`. This will only be applied to
`𝓕 = 𝓤 β` when `β` is equipped with a `UniformSpace` structure, but it is useful to define it for
any filter in order to be able to state that it has a lower adjoint
(see `UniformFun.gc`). |
protected filter (𝓕 : Filter <| β × β) : Filter ((α →ᵤ β) × (α →ᵤ β)) :=
(UniformFun.basis α β 𝓕).filter | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | filter | For `𝓕 : Filter (β × β)`, this is the filter generated by the filter basis
`UniformFun.basis α β 𝓕`. For `𝓕 = 𝓤 β`, this will be the uniformity of uniform
convergence on `α`. |
protected phi (α β : Type*) (uvx : ((α →ᵤ β) × (α →ᵤ β)) × α) : β × β :=
(uvx.fst.fst uvx.2, uvx.1.2 uvx.2)
set_option quotPrecheck false -- Porting note: we need a `[quot_precheck]` instance on fbinop%
/- This is a lower adjoint to `UniformFun.filter` (see `UniformFun.gc`).
The exact definition of the lower adjoint `l` is not interesting; we will only use that it exists
(in `UniformFun.mono` and `UniformFun.iInf_eq`) and that
`l (Filter.map (Prod.map f f) 𝓕) = Filter.map (Prod.map ((∘) f) ((∘) f)) (l 𝓕)` for each
`𝓕 : Filter (γ × γ)` and `f : γ → α` (in `UniformFun.comap_eq`). -/
local notation "lowerAdjoint" => fun 𝓐 => map (UniformFun.phi α β) (𝓐 ×ˢ ⊤) | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | phi | null |
protected gc : GaloisConnection lowerAdjoint fun 𝓕 => UniformFun.filter α β 𝓕 := by
intro 𝓐 𝓕
symm
calc
𝓐 ≤ UniformFun.filter α β 𝓕 ↔ (UniformFun.basis α β 𝓕).sets ⊆ 𝓐.sets := by
rw [UniformFun.filter, ← FilterBasis.generate, le_generate_iff]
_ ↔ ∀ U ∈ 𝓕, UniformFun.gen α β U ∈ 𝓐 := image_subset_iff
_ ↔ ∀ U ∈ 𝓕,
{ uv | ∀ x, (uv, x) ∈ { t : ((α →ᵤ β) × (α →ᵤ β)) × α | (t.1.1 t.2, t.1.2 t.2) ∈ U } } ∈
𝓐 :=
Iff.rfl
_ ↔ ∀ U ∈ 𝓕,
{ uvx : ((α →ᵤ β) × (α →ᵤ β)) × α | (uvx.1.1 uvx.2, uvx.1.2 uvx.2) ∈ U } ∈
𝓐 ×ˢ (⊤ : Filter α) :=
forall₂_congr fun U _hU => mem_prod_top.symm
_ ↔ lowerAdjoint 𝓐 ≤ 𝓕 := Iff.rfl
variable [UniformSpace β] | theorem | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | gc | The function `UniformFun.filter α β : Filter (β × β) → Filter ((α →ᵤ β) × (α →ᵤ β))`
has a lower adjoint `l` (in the sense of `GaloisConnection`). The exact definition of `l` is not
interesting; we will only use that it exists (in `UniformFun.mono` and
`UniformFun.iInf_eq`) and that
`l (Filter.map (Prod.map f f) 𝓕) = Filter.map (Prod.map ((∘) f) ((∘) f)) (l 𝓕)` for each
`𝓕 : Filter (γ × γ)` and `f : γ → α` (in `UniformFun.comap_eq`). |
protected uniformCore : UniformSpace.Core (α →ᵤ β) :=
UniformSpace.Core.mkOfBasis (UniformFun.basis α β (𝓤 β))
(fun _ ⟨_, hV, hVU⟩ _ => hVU ▸ fun _ => refl_mem_uniformity hV)
(fun _ ⟨V, hV, hVU⟩ =>
hVU ▸
⟨UniformFun.gen α β (Prod.swap ⁻¹' V), ⟨Prod.swap ⁻¹' V, tendsto_swap_uniformity hV, rfl⟩,
fun _ huv x => huv x⟩)
fun _ ⟨_, hV, hVU⟩ =>
hVU ▸
let ⟨W, hW, hWV⟩ := comp_mem_uniformity_sets hV
⟨UniformFun.gen α β W, ⟨W, hW, rfl⟩, fun _ ⟨w, huw, hwv⟩ x => hWV ⟨w x, ⟨huw x, hwv x⟩⟩⟩ | def | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | uniformCore | Core of the uniform structure of uniform convergence. |
uniformSpace : UniformSpace (α →ᵤ β) :=
UniformSpace.ofCore (UniformFun.uniformCore α β) | instance | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | uniformSpace | Uniform structure of uniform convergence, declared as an instance on `α →ᵤ β`.
We will denote it `𝒰(α, β, uβ)` in the rest of this file. |
topologicalSpace : TopologicalSpace (α →ᵤ β) :=
inferInstance
local notation "𝒰(" α ", " β ", " u ")" => @UniformFun.uniformSpace α β u | instance | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | topologicalSpace | Topology of uniform convergence, declared as an instance on `α →ᵤ β`. |
protected hasBasis_uniformity :
(𝓤 (α →ᵤ β)).HasBasis (· ∈ 𝓤 β) (UniformFun.gen α β) :=
(UniformFun.isBasis_gen α β (𝓤 β)).hasBasis | theorem | Topology | [
"Mathlib.Topology.Coherent",
"Mathlib.Topology.UniformSpace.Equiv",
"Mathlib.Topology.UniformSpace.Pi",
"Mathlib.Topology.UniformSpace.UniformApproximation"
] | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | hasBasis_uniformity | By definition, the uniformity of `α →ᵤ β` admits the family `{(f, g) | ∀ x, (f x, g x) ∈ V}`
for `V ∈ 𝓤 β` as a filter basis. |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.