statement stringlengths 1 2.93k | proof stringlengths 0 19.2k | type stringclasses 13
values | symbolic_name stringlengths 1 131 | library stringlengths 4 62 | filename stringlengths 20 95 | imports listlengths 0 10 | deps listlengths 0 64 | docstring stringlengths 0 4.95k | source_url stringclasses 1
value | commit stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|
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 | uniformCauchySeqOn_iff_uniformCauchySeqOnFilter | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"UniformCauchySeqOn",
"UniformCauchySeqOnFilter"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
UniformCauchySeqOn.uniformCauchySeqOnFilter (hF : UniformCauchySeqOn F p s) :
UniformCauchySeqOnFilter F p (𝓟 s) | by rwa [← uniformCauchySeqOn_iff_uniformCauchySeqOnFilter] | theorem | UniformCauchySeqOn.uniformCauchySeqOnFilter | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"UniformCauchySeqOn",
"UniformCauchySeqOnFilter",
"uniformCauchySeqOn_iff_uniformCauchySeqOnFilter"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 htmem <| SetRel.prodMk_mem_comp (htsymm hl) hr | theorem | TendstoUniformlyOnFilter.uniformCauchySeqOnFilter | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"SetRel.prodMk_mem_comp",
"TendstoUniformlyOnFilter",
"UniformCauchySeqOnFilter",
"comp_symm_of_uniformity"
] | A sequence that converges uniformly is also uniformly Cauchy | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
TendstoUniformlyOn.uniformCauchySeqOn (hF : TendstoUniformlyOn F f p s) :
UniformCauchySeqOn F p s | uniformCauchySeqOn_iff_uniformCauchySeqOnFilter.mpr
hF.tendstoUniformlyOnFilter.uniformCauchySeqOnFilter | theorem | TendstoUniformlyOn.uniformCauchySeqOn | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"TendstoUniformlyOn",
"UniformCauchySeqOn"
] | A sequence that converges uniformly is also uniformly Cauchy | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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]
-- Proof idea: |f_n(x) - f(x)| ≤ |f_n(x) - f_m(x)| + |f_m(x) - f(x)|. We choose `n`
-- so that |f_n(x) - f_m(x)| is uniformly small across `s` whenever `m ≥ n`. Then for
-- a fixed `x`, we choos... | theorem | UniformCauchySeqOnFilter.tendstoUniformlyOnFilter_of_tendsto | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter.eventually_swap_iff",
"Set.mem_of_mem_of_subset",
"TendstoUniformlyOnFilter",
"Uniform.tendsto_nhds_right",
"UniformCauchySeqOnFilter",
"comp_symm_of_uniformity"
] | A uniformly Cauchy sequence converges uniformly to its limit | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 | UniformCauchySeqOn.tendstoUniformlyOn_of_tendsto | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"TendstoUniformlyOn",
"UniformCauchySeqOn"
] | A uniformly Cauchy sequence converges uniformly to its limit | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 | UniformCauchySeqOnFilter.mono_left | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"Filter.prod_mono",
"UniformCauchySeqOnFilter"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | UniformCauchySeqOnFilter.mono_right | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"UniformCauchySeqOnFilter"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | UniformCauchySeqOn.mono | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"UniformCauchySeqOn",
"uniformCauchySeqOn_iff_uniformCauchySeqOnFilter"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | UniformCauchySeqOnFilter.comp | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"UniformCauchySeqOnFilter"
] | Composing on the right by a function preserves uniform Cauchy sequences | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 | UniformCauchySeqOn.comp | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"UniformCauchySeqOn",
"uniformCauchySeqOn_iff_uniformCauchySeqOnFilter"
] | Composing on the right by a function preserves uniform Cauchy sequences | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 | UniformContinuous.comp_uniformCauchySeqOn | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"UniformCauchySeqOn",
"UniformContinuous",
"UniformSpace"
] | Composing on the left by a uniformly continuous function preserves
uniform Cauchy sequences | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 ⟨_, ... | theorem | UniformCauchySeqOn.prodMap | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"Set",
"Set.image_subset_iff",
"UniformCauchySeqOn",
"UniformSpace",
"uniformity_prod_eq_prod"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | UniformCauchySeqOn.prod | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"UniformCauchySeqOn",
"UniformSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | UniformCauchySeqOn.prod' | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"UniformCauchySeqOn",
"UniformSpace"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | UniformCauchySeqOn.cauchy_map | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Cauchy",
"UniformCauchySeqOn",
"cauchy_map_iff"
] | If a sequence of functions is uniformly Cauchy on a set, then the values at each point form
a Cauchy sequence. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 | UniformCauchySeqOn.cauchySeq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"CauchySeq",
"SemilatticeSup",
"UniformCauchySeqOn"
] | 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. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 | tendstoUniformlyOn_of_seq_tendstoUniformlyOn | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"TendstoUniformlyOn",
"tendstoUniformlyOn_iff_tendsto"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | TendstoUniformlyOn.seq_tendstoUniformlyOn | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"TendstoUniformlyOn",
"tendstoUniformlyOn_iff_tendsto"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | tendstoUniformlyOn_iff_seq_tendstoUniformlyOn | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"TendstoUniformlyOn"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | tendstoUniformly_iff_seq_tendstoUniformly | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Filter",
"TendstoUniformly",
"tendstoUniformlyOn_iff_seq_tendstoUniformlyOn",
"tendstoUniformlyOn_univ"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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.m... | theorem | TendstoUniformlyOnFilter.tendsto_of_eventually_tendsto | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"Set.preimage",
"TendstoUniformlyOnFilter",
"comp3_mem_uniformity"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 | TendstoUniformly.tendsto_of_eventually_tendsto | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergence.lean | [] | [
"TendstoUniformly",
"le_top"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
UniformFun (α β : Type*) | α → β | def | UniformFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | The type of functions from `α` to `β` equipped with the uniform structure and topology of
uniform convergence. We denote it `α →ᵤ β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
UniformOnFun (α β : Type*) (_ : Set (Set α)) | α → β
@[inherit_doc] scoped[UniformConvergence] notation:25 α " →ᵤ " β:0 => UniformFun α β
@[inherit_doc] scoped[UniformConvergence] notation:25 α " →ᵤ[" 𝔖 "] " β:0 => UniformOnFun α β 𝔖 | def | UniformOnFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun"
] | 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 `α →ᵤ[𝔖] β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
UniformFun.ofFun : (α → β) ≃ (α →ᵤ β) | ⟨fun x => x, fun x => x, fun _ => rfl, fun _ => rfl⟩ | def | UniformFun.ofFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | Reinterpret `f : α → β` as an element of `α →ᵤ β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
UniformOnFun.ofFun (𝔖) : (α → β) ≃ (α →ᵤ[𝔖] β) | ⟨fun x => x, fun x => x, fun _ => rfl, fun _ => rfl⟩ | def | UniformOnFun.ofFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | Reinterpret `f : α → β` as an element of `α →ᵤ[𝔖] β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
UniformFun.toFun : (α →ᵤ β) ≃ (α → β) | UniformFun.ofFun.symm | def | UniformFun.toFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | Reinterpret `f : α →ᵤ β` as an element of `α → β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
UniformOnFun.toFun (𝔖) : (α →ᵤ[𝔖] β) ≃ (α → β) | (UniformOnFun.ofFun 𝔖).symm | def | UniformOnFun.toFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformOnFun.ofFun",
"symm"
] | Reinterpret `f : α →ᵤ[𝔖] β` as an element of `α → β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
UniformFun.toFun_ofFun (f : α → β) : toFun (ofFun f) = f | rfl | lemma | UniformFun.toFun_ofFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
UniformFun.ofFun_toFun (f : α →ᵤ β) : ofFun (toFun f) = f | rfl | lemma | UniformFun.ofFun_toFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
UniformOnFun.toFun_ofFun (f : α → β) : toFun 𝔖 (ofFun 𝔖 f) = f | rfl | lemma | UniformOnFun.toFun_ofFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
UniformOnFun.ofFun_toFun (f : α →ᵤ[𝔖] β) : ofFun 𝔖 (toFun 𝔖 f) = f | rfl | lemma | UniformOnFun.ofFun_toFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
gen (V : Set (β × β)) : Set ((α →ᵤ β) × (α →ᵤ β)) | { uv : (α →ᵤ β) × (α →ᵤ β) | ∀ x, (toFun uv.1 x, toFun uv.2 x) ∈ V } | def | UniformFun.gen | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set"
] | 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`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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 | UniformFun.isBasis_gen | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Filter",
"Set",
"UniformFun.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... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
basis (𝓕 : Filter <| β × β) : FilterBasis ((α →ᵤ β) × (α →ᵤ β)) | (UniformFun.isBasis_gen α β 𝓕).filterBasis | def | UniformFun.basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Filter",
"FilterBasis",
"UniformFun.isBasis_gen"
] | 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 ha... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
filter (𝓕 : Filter <| β × β) : Filter ((α →ᵤ β) × (α →ᵤ β)) | (UniformFun.basis α β 𝓕).filter | def | UniformFun.filter | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Filter",
"UniformFun.basis"
] | For `𝓕 : Filter (β × β)`, this is the filter generated by the filter basis
`UniformFun.basis α β 𝓕`. For `𝓕 = 𝓤 β`, this will be the uniformity of uniform
convergence on `α`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
phi (α β : Type*) (uvx : ((α →ᵤ β) × (α →ᵤ β)) × α) : β × β | (uvx.fst.fst uvx.2, uvx.1.2 uvx.2) | def | UniformFun.phi | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
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 : ((α →ᵤ β) × (α →... | theorem | UniformFun.gc | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Filter",
"FilterBasis.generate",
"GaloisConnection",
"UniformFun.basis",
"UniformFun.filter",
"UniformFun.gen",
"symm"
] | 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) 𝓕) = ... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
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⟩ ... | def | UniformFun.uniformCore | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.basis",
"UniformSpace.Core",
"UniformSpace.Core.mkOfBasis",
"comp_mem_uniformity_sets",
"refl_mem_uniformity",
"tendsto_swap_uniformity"
] | Core of the uniform structure of uniform convergence. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformSpace : UniformSpace (α →ᵤ β) | UniformSpace.ofCore (UniformFun.uniformCore α β) | instance | UniformFun.uniformSpace | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.uniformCore",
"UniformSpace",
"UniformSpace.ofCore"
] | Uniform structure of uniform convergence, declared as an instance on `α →ᵤ β`.
We will denote it `𝒰(α, β, uβ)` in the rest of this file. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
topologicalSpace : TopologicalSpace (α →ᵤ β) | inferInstance | instance | UniformFun.topologicalSpace | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"TopologicalSpace"
] | Topology of uniform convergence, declared as an instance on `α →ᵤ β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_uniformity :
(𝓤 (α →ᵤ β)).HasBasis (· ∈ 𝓤 β) (UniformFun.gen α β) | (UniformFun.isBasis_gen α β (𝓤 β)).hasBasis | theorem | UniformFun.hasBasis_uniformity | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.gen",
"UniformFun.isBasis_gen"
] | By definition, the uniformity of `α →ᵤ β` admits the family `{(f, g) | ∀ x, (f x, g x) ∈ V}`
for `V ∈ 𝓤 β` as a filter basis. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_uniformity_of_basis {ι : Sort*} {p : ι → Prop} {s : ι → Set (β × β)}
(h : (𝓤 β).HasBasis p s) : (𝓤 (α →ᵤ β)).HasBasis p (UniformFun.gen α β ∘ s) | (UniformFun.hasBasis_uniformity α β).to_hasBasis
(fun _ hU =>
let ⟨i, hi, hiU⟩ := h.mem_iff.mp hU
⟨i, hi, fun _ huv x => hiU (huv x)⟩)
fun i hi => ⟨s i, h.mem_of_mem hi, subset_rfl⟩ | theorem | UniformFun.hasBasis_uniformity_of_basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.gen",
"UniformFun.hasBasis_uniformity"
] | The uniformity of `α →ᵤ β` admits the family `{(f, g) | ∀ x, (f x, g x) ∈ V}` for `V ∈ 𝓑` as
a filter basis, for any basis `𝓑` of `𝓤 β` (in the case `𝓑 = (𝓤 β).as_basis` this is true by
definition). | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_nhds_of_basis (f) {p : ι → Prop} {s : ι → Set (β × β)}
(h : HasBasis (𝓤 β) p s) :
(𝓝 f).HasBasis p fun i => { g | (f, g) ∈ UniformFun.gen α β (s i) } | nhds_basis_uniformity' (UniformFun.hasBasis_uniformity_of_basis α β h) | theorem | UniformFun.hasBasis_nhds_of_basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.gen",
"UniformFun.hasBasis_uniformity_of_basis",
"nhds_basis_uniformity'"
] | For `f : α →ᵤ β`, `𝓝 f` admits the family `{g | ∀ x, (f x, g x) ∈ V}` for `V ∈ 𝓑` as a filter
basis, for any basis `𝓑` of `𝓤 β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_nhds (f) :
(𝓝 f).HasBasis (fun V => V ∈ 𝓤 β) fun V => { g | (f, g) ∈ UniformFun.gen α β V } | UniformFun.hasBasis_nhds_of_basis α β f (Filter.basis_sets _) | theorem | UniformFun.hasBasis_nhds | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Filter.basis_sets",
"UniformFun.gen",
"UniformFun.hasBasis_nhds_of_basis"
] | For `f : α →ᵤ β`, `𝓝 f` admits the family `{g | ∀ x, (f x, g x) ∈ V}` for `V ∈ 𝓤 β` as a
filter basis. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformContinuous_eval (x : α) :
UniformContinuous (Function.eval x ∘ toFun : (α →ᵤ β) → β) | by
change _ ≤ _
rw [map_le_iff_le_comap,
(UniformFun.hasBasis_uniformity α β).le_basis_iff ((𝓤 _).basis_sets.comap _)]
exact fun U hU => ⟨U, hU, fun uv huv => huv x⟩ | theorem | UniformFun.uniformContinuous_eval | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Function.eval",
"UniformContinuous",
"UniformFun.hasBasis_uniformity"
] | Evaluation at a fixed point is uniformly continuous on `α →ᵤ β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
mem_gen {β} {f g : α →ᵤ β} {V : Set (β × β)} :
(f, g) ∈ UniformFun.gen α β V ↔ ∀ x, (toFun f x, toFun g x) ∈ V | .rfl | lemma | UniformFun.mem_gen | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.gen"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
mono : Monotone (@UniformFun.uniformSpace α γ) | fun _ _ hu =>
(UniformFun.gc α γ).monotone_u hu | theorem | UniformFun.mono | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Monotone",
"UniformFun.gc",
"UniformFun.uniformSpace"
] | If `u₁` and `u₂` are two uniform structures on `γ` and `u₁ ≤ u₂`, then
`𝒰(α, γ, u₁) ≤ 𝒰(α, γ, u₂)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
iInf_eq {u : ι → UniformSpace γ} : 𝒰(α, γ, (⨅ i, u i)) = ⨅ i, 𝒰(α, γ, u i) | by
-- This follows directly from the fact that the upper adjoint in a Galois connection maps
-- infimas to infimas.
ext : 1
change UniformFun.filter α γ 𝓤[⨅ i, u i] = 𝓤[⨅ i, 𝒰(α, γ, u i)]
rw [iInf_uniformity, iInf_uniformity]
exact (UniformFun.gc α γ).u_iInf | theorem | UniformFun.iInf_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.filter",
"UniformFun.gc",
"UniformSpace",
"iInf_uniformity"
] | If `u` is a family of uniform structures on `γ`, then
`𝒰(α, γ, (⨅ i, u i)) = ⨅ i, 𝒰(α, γ, u i)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
inf_eq {u₁ u₂ : UniformSpace γ} :
𝒰(α, γ, u₁ ⊓ u₂) = 𝒰(α, γ, u₁) ⊓ 𝒰(α, γ, u₂) | by
-- This follows directly from the fact that the upper adjoint in a Galois connection maps
-- infimas to infimas.
rw [inf_eq_iInf, inf_eq_iInf, UniformFun.iInf_eq]
refine iInf_congr fun i => ?_
cases i <;> rfl | theorem | UniformFun.inf_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.iInf_eq",
"UniformSpace"
] | If `u₁` and `u₂` are two uniform structures on `γ`, then
`𝒰(α, γ, u₁ ⊓ u₂) = 𝒰(α, γ, u₁) ⊓ 𝒰(α, γ, u₂)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
postcomp_isUniformInducing [UniformSpace γ] {f : γ → β}
(hf : IsUniformInducing f) : IsUniformInducing (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β) | ⟨((UniformFun.hasBasis_uniformity _ _).comap _).eq_of_same_basis <|
UniformFun.hasBasis_uniformity_of_basis _ _ (hf.basis_uniformity (𝓤 β).basis_sets)⟩ | lemma | UniformFun.postcomp_isUniformInducing | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"IsUniformInducing",
"UniformFun.hasBasis_uniformity",
"UniformFun.hasBasis_uniformity_of_basis",
"UniformSpace",
"comap"
] | Post-composition by a uniform inducing function is
a uniform inducing function for the uniform structures of uniform convergence.
More precisely, if `f : γ → β` is uniform inducing,
then `(f ∘ ·) : (α →ᵤ γ) → (α →ᵤ β)` is uniform inducing. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
postcomp_isUniformEmbedding [UniformSpace γ] {f : γ → β}
(hf : IsUniformEmbedding f) :
IsUniformEmbedding (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β) | where
toIsUniformInducing := UniformFun.postcomp_isUniformInducing hf.isUniformInducing
injective _ _ H := funext fun _ ↦ hf.injective (congrFun H _) | theorem | UniformFun.postcomp_isUniformEmbedding | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"IsUniformEmbedding",
"UniformFun.postcomp_isUniformInducing",
"UniformSpace"
] | Post-composition by a uniform embedding is
a uniform embedding for the uniform structures of uniform convergence.
More precisely, if `f : γ → β` is a uniform embedding,
then `(f ∘ ·) : (α →ᵤ γ) → (α →ᵤ β)` is a uniform embedding. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
comap_eq {f : γ → β} :
𝒰(α, γ, ‹UniformSpace β›.comap f) = 𝒰(α, β, _).comap (f ∘ ·) | by
letI : UniformSpace γ := .comap f ‹_›
exact (UniformFun.postcomp_isUniformInducing (f := f) ⟨rfl⟩).comap_uniformSpace.symm | theorem | UniformFun.comap_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.postcomp_isUniformInducing",
"UniformSpace",
"comap"
] | If `u` is a uniform structures on `β` and `f : γ → β`, then
`𝒰(α, γ, comap f u) = comap (fun g ↦ f ∘ g) 𝒰(α, γ, u₁)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
postcomp_uniformContinuous [UniformSpace γ] {f : γ → β}
(hf : UniformContinuous f) :
UniformContinuous (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β) | by
-- This is a direct consequence of `UniformFun.comap_eq`
refine uniformContinuous_iff_le_comap.mpr ?_
calc
𝒰(α, γ, _) ≤ 𝒰(α, γ, ‹UniformSpace β›.comap f) :=
UniformFun.mono (uniformContinuous_iff_le_comap.mp hf)
_ = 𝒰(α, β, _).comap (f ∘ ·) := by exact UniformFun.comap_eq | theorem | UniformFun.postcomp_uniformContinuous | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformContinuous",
"UniformFun.comap_eq",
"UniformFun.mono",
"UniformSpace",
"comap"
] | Post-composition by a uniformly continuous function is uniformly continuous on `α →ᵤ β`.
More precisely, if `f : γ → β` is uniformly continuous, then `(fun g ↦ f ∘ g) : (α →ᵤ γ) → (α →ᵤ β)`
is uniformly continuous. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
congrRight [UniformSpace γ] (e : γ ≃ᵤ β) : (α →ᵤ γ) ≃ᵤ (α →ᵤ β) | { Equiv.piCongrRight fun _ => e.toEquiv with
uniformContinuous_toFun := UniformFun.postcomp_uniformContinuous e.uniformContinuous
uniformContinuous_invFun := UniformFun.postcomp_uniformContinuous e.symm.uniformContinuous } | def | UniformFun.congrRight | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Equiv.piCongrRight",
"UniformFun.postcomp_uniformContinuous",
"UniformSpace"
] | Turn a uniform isomorphism `γ ≃ᵤ β` into a uniform isomorphism `(α →ᵤ γ) ≃ᵤ (α →ᵤ β)` by
post-composing. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
precomp_uniformContinuous {f : γ → α} :
UniformContinuous fun g : α →ᵤ β => ofFun (toFun g ∘ f) | by
-- Here we simply go back to filter bases.
rw [UniformContinuous,
(UniformFun.hasBasis_uniformity α β).tendsto_iff (UniformFun.hasBasis_uniformity γ β)]
exact fun U hU => ⟨U, hU, fun uv huv x => huv (f x)⟩ | theorem | UniformFun.precomp_uniformContinuous | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformContinuous",
"UniformFun.hasBasis_uniformity"
] | Pre-composition by any function is uniformly continuous for the uniform structures of
uniform convergence.
More precisely, for any `f : γ → α`, the function `(· ∘ f) : (α →ᵤ β) → (γ →ᵤ β)` is uniformly
continuous. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
congrLeft (e : γ ≃ α) : (γ →ᵤ β) ≃ᵤ (α →ᵤ β) | where
toEquiv := e.arrowCongr (.refl _)
uniformContinuous_toFun := UniformFun.precomp_uniformContinuous
uniformContinuous_invFun := UniformFun.precomp_uniformContinuous | def | UniformFun.congrLeft | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.precomp_uniformContinuous",
"refl"
] | Turn a bijection `γ ≃ α` into a uniform isomorphism
`(γ →ᵤ β) ≃ᵤ (α →ᵤ β)` by pre-composing. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformContinuous_toFun : UniformContinuous (toFun : (α →ᵤ β) → α → β) | by
-- By definition of the product uniform structure, this is just `uniform_continuous_eval`.
rw [uniformContinuous_pi]
intro x
exact uniformContinuous_eval β x | theorem | UniformFun.uniformContinuous_toFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformContinuous",
"uniformContinuous_pi"
] | The natural map `UniformFun.toFun` from `α →ᵤ β` to `α → β` is uniformly continuous.
In other words, the uniform structure of uniform convergence is finer than that of pointwise
convergence, aka the product uniform structure. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
tendsto_iff_tendstoUniformly {F : ι → α →ᵤ β} {f : α →ᵤ β} :
Tendsto F p (𝓝 f) ↔ TendstoUniformly (toFun ∘ F) (toFun f) p | by
rw [(UniformFun.hasBasis_nhds α β f).tendsto_right_iff, TendstoUniformly]
simp only [mem_setOf, UniformFun.gen, Function.comp_def] | theorem | UniformFun.tendsto_iff_tendstoUniformly | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"TendstoUniformly",
"UniformFun.gen",
"UniformFun.hasBasis_nhds"
] | The topology of uniform convergence indeed gives the same notion of convergence as
`TendstoUniformly`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformEquivProdArrow [UniformSpace γ] : (α →ᵤ β × γ) ≃ᵤ (α →ᵤ β) × (α →ᵤ γ) | -- Denote `φ` this bijection. We want to show that
-- `comap φ (𝒰(α, β, uβ) × 𝒰(α, γ, uγ)) = 𝒰(α, β × γ, uβ × uγ)`.
-- But `uβ × uγ` is defined as `comap fst uβ ⊓ comap snd uγ`, so we just have to apply
-- `UniformFun.inf_eq` and `UniformFun.comap_eq`, which leaves us to check
-- that some square commutes.
... | def | UniformFun.uniformEquivProdArrow | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Equiv.arrowProdEquivProdArrow",
"Equiv.toUniformEquivOfIsUniformInducing",
"UniformFun",
"UniformFun.comap_eq",
"UniformFun.inf_eq",
"UniformSpace",
"UniformSpace.comap",
"UniformSpace.comap_comap",
"UniformSpace.comap_inf",
"comap",
"instUniformSpaceProd",
"symm",
"uniformity_comap"
] | The natural bijection between `α → β × γ` and `(α → β) × (α → γ)`, upgraded to a uniform
isomorphism between `α →ᵤ β × γ` and `(α →ᵤ β) × (α →ᵤ γ)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformEquivPiComm : UniformEquiv (α →ᵤ ∀ i, δ i) (∀ i, α →ᵤ δ i) | -- Denote `φ` this bijection. We want to show that
-- `comap φ (Π i, 𝒰(α, δ i, uδ i)) = 𝒰(α, (Π i, δ i), (Π i, uδ i))`.
-- But `Π i, uδ i` is defined as `⨅ i, comap (eval i) (uδ i)`, so we just have to apply
-- `UniformFun.iInf_eq` and `UniformFun.comap_eq`, which leaves us to check
-- that some squar... | def | UniformFun.uniformEquivPiComm | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Equiv.piComm",
"Equiv.toUniformEquivOfIsUniformInducing",
"Function.swap",
"Pi.uniformSpace",
"UniformEquiv",
"UniformFun.comap_eq",
"UniformFun.iInf_eq",
"UniformSpace.comap_comap",
"UniformSpace.comap_iInf",
"UniformSpace.ofCoreEq_toCore",
"comap",
"uniformity_comap"
] | The natural bijection between `α → Π i, δ i` and `Π i, α → δ i`, upgraded to a uniform
isomorphism between `α →ᵤ (Π i, δ i)` and `Π i, α →ᵤ δ i`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isClosed_setOf_continuous [TopologicalSpace α] :
IsClosed {f : α →ᵤ β | Continuous (toFun f)} | by
refine isClosed_iff_forall_filter.2 fun f u _ hu huf ↦ ?_
rw [← tendsto_id', UniformFun.tendsto_iff_tendstoUniformly] at huf
exact huf.continuous <| Eventually.frequently (le_principal_iff.mp hu) | theorem | UniformFun.isClosed_setOf_continuous | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Continuous",
"IsClosed",
"TopologicalSpace",
"UniformFun.tendsto_iff_tendstoUniformly"
] | The set of continuous functions is closed in the uniform convergence topology.
This is a simple wrapper over `TendstoUniformly.continuous`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformSpace_eq_inf_precomp_of_cover {δ₁ δ₂ : Type*} (φ₁ : δ₁ → α) (φ₂ : δ₂ → α)
(h_cover : range φ₁ ∪ range φ₂ = univ) :
𝒰(α, β, _) =
.comap (ofFun ∘ (· ∘ φ₁) ∘ toFun) 𝒰(δ₁, β, _) ⊓
.comap (ofFun ∘ (· ∘ φ₂) ∘ toFun) 𝒰(δ₂, β, _) | by
ext : 1
refine le_antisymm (le_inf ?_ ?_) ?_
· exact tendsto_iff_comap.mp UniformFun.precomp_uniformContinuous
· exact tendsto_iff_comap.mp UniformFun.precomp_uniformContinuous
· refine
(UniformFun.hasBasis_uniformity δ₁ β |>.comap _).inf
(UniformFun.hasBasis_uniformity δ₂ β |>.comap _)
... | theorem | UniformFun.uniformSpace_eq_inf_precomp_of_cover | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.hasBasis_uniformity",
"UniformFun.precomp_uniformContinuous",
"comap",
"le_antisymm"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
uniformSpace_eq_iInf_precomp_of_cover {δ : ι → Type*} (φ : Π i, δ i → α)
(h_cover : ∃ I : Set ι, I.Finite ∧ ⋃ i ∈ I, range (φ i) = univ) :
𝒰(α, β, _) = ⨅ i, .comap (ofFun ∘ (· ∘ φ i) ∘ toFun) 𝒰(δ i, β, _) | by
ext : 1
simp_rw [iInf_uniformity, uniformity_comap]
refine le_antisymm (le_iInf fun i ↦ tendsto_iff_comap.mp UniformFun.precomp_uniformContinuous) ?_
rcases h_cover with ⟨I, I_finite, I_cover⟩
refine HasBasis.iInf (fun i : ι ↦ UniformFun.hasBasis_uniformity (δ i) β |>.comap _)
|>.le_basis_iff (Unifor... | theorem | UniformFun.uniformSpace_eq_iInf_precomp_of_cover | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.hasBasis_uniformity",
"UniformFun.precomp_uniformContinuous",
"comap",
"iInf_uniformity",
"le_antisymm",
"uniformity_comap"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
gen (𝔖) (S : Set α) (V : Set (β × β)) : Set ((α →ᵤ[𝔖] β) × (α →ᵤ[𝔖] β)) | { uv : (α →ᵤ[𝔖] β) × (α →ᵤ[𝔖] β) | ∀ x ∈ S, (toFun 𝔖 uv.1 x, toFun 𝔖 uv.2 x) ∈ V } | def | UniformOnFun.gen | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set"
] | Basis sets for the uniformity of `𝔖`-convergence: for `S : Set α` and `V : Set (β × β)`,
`gen 𝔖 S V` is the set of pairs `(f, g)` of functions `α →ᵤ[𝔖] β` such that
`∀ x ∈ S, (f x, g x) ∈ V`. Note that the family `𝔖 : Set (Set α)` is only used to specify which
type alias of `α → β` to use here. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
gen_eq_preimage_restrict {𝔖} (S : Set α) (V : Set (β × β)) :
UniformOnFun.gen 𝔖 S V =
Prod.map (S.restrict ∘ UniformFun.toFun) (S.restrict ∘ UniformFun.toFun) ⁻¹'
UniformFun.gen S β V | by
ext uv
exact ⟨fun h ⟨x, hx⟩ => h x hx, fun h x hx => h ⟨x, hx⟩⟩ | theorem | UniformOnFun.gen_eq_preimage_restrict | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.gen",
"UniformFun.toFun",
"UniformOnFun.gen"
] | For `S : Set α` and `V : Set (β × β)`, we have
`UniformOnFun.gen 𝔖 S V = (S.restrict × S.restrict) ⁻¹' (UniformFun.gen S β V)`.
This is the crucial fact for proving that the family `UniformOnFun.gen S V` for `S ∈ 𝔖` and
`V ∈ 𝓤 β` is indeed a basis for the uniformity `α →ᵤ[𝔖] β` endowed with `𝒱(α, β, 𝔖, uβ)`
the u... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
gen_mono {𝔖} {S S' : Set α} {V V' : Set (β × β)} (hS : S' ⊆ S) (hV : V ⊆ V') :
UniformOnFun.gen 𝔖 S V ⊆ UniformOnFun.gen 𝔖 S' V' | fun _uv h x hx => hV (h x <| hS hx) | theorem | UniformOnFun.gen_mono | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformOnFun.gen"
] | `UniformOnFun.gen` is antitone in the first argument and monotone in the second. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isBasis_gen (𝔖 : Set (Set α)) (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖)
(𝓑 : FilterBasis <| β × β) :
IsBasis (fun SV : Set α × Set (β × β) => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓑) fun SV =>
UniformOnFun.gen 𝔖 SV.1 SV.2 | ⟨h.prod 𝓑.nonempty, fun {U₁V₁ U₂V₂} h₁ h₂ =>
let ⟨U₃, hU₃, hU₁₃, hU₂₃⟩ := h' U₁V₁.1 h₁.1 U₂V₂.1 h₂.1
let ⟨V₃, hV₃, hV₁₂₃⟩ := 𝓑.inter_sets h₁.2 h₂.2
⟨⟨U₃, V₃⟩,
⟨⟨hU₃, hV₃⟩, fun _ H =>
⟨fun x hx => (hV₁₂₃ <| H x <| hU₁₃ hx).1, fun x hx => (hV₁₂₃ <| H x <| hU₂₃ hx).2⟩⟩⟩⟩ | theorem | UniformOnFun.isBasis_gen | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"DirectedOn",
"FilterBasis",
"Set",
"UniformOnFun.gen"
] | If `𝔖 : Set (Set α)` is nonempty and directed and `𝓑` is a filter basis on `β × β`, then the
family `UniformOnFun.gen 𝔖 S V` for `S ∈ 𝔖` and `V ∈ 𝓑` is a filter basis on
`(α →ᵤ[𝔖] β) × (α →ᵤ[𝔖] β)`.
We will show in `has_basis_uniformity_of_basis` that, if `𝓑` is a basis for `𝓤 β`, then the
corresponding filter... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformSpace : UniformSpace (α →ᵤ[𝔖] β) | ⨅ (s : Set α) (_ : s ∈ 𝔖),
.comap (UniformFun.ofFun ∘ s.restrict ∘ UniformOnFun.toFun 𝔖) 𝒰(s, β, _) | instance | UniformOnFun.uniformSpace | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.ofFun",
"UniformOnFun.toFun",
"UniformSpace",
"comap"
] | Uniform structure of `𝔖`-convergence, i.e uniform convergence on the elements of `𝔖`,
declared as an instance on `α →ᵤ[𝔖] β`. It is defined as the infimum, for `S ∈ 𝔖`, of the pullback
by `S.restrict`, the map of restriction to `S`, of the uniform structure `𝒰(s, β, uβ)` on
`↥S →ᵤ β`. We will denote it `𝒱(α, β, �... | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
topologicalSpace : TopologicalSpace (α →ᵤ[𝔖] β) | 𝒱(α, β, 𝔖, _).toTopologicalSpace | instance | UniformOnFun.topologicalSpace | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"TopologicalSpace"
] | Topology of `𝔖`-convergence, i.e uniform convergence on the elements of `𝔖`, declared as an
instance on `α →ᵤ[𝔖] β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
topologicalSpace_eq :
UniformOnFun.topologicalSpace α β 𝔖 =
⨅ (s : Set α) (_ : s ∈ 𝔖), TopologicalSpace.induced
(UniformFun.ofFun ∘ s.restrict ∘ toFun 𝔖) (UniformFun.topologicalSpace s β) | by
simp only [UniformOnFun.topologicalSpace, UniformSpace.toTopologicalSpace_iInf]
rfl | theorem | UniformOnFun.topologicalSpace_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"TopologicalSpace.induced",
"UniformFun.ofFun",
"UniformFun.topologicalSpace",
"UniformOnFun.topologicalSpace",
"UniformSpace.toTopologicalSpace_iInf"
] | The topology of `𝔖`-convergence is the infimum, for `S ∈ 𝔖`, of topology induced by the map
of `S.restrict : (α →ᵤ[𝔖] β) → (↥S →ᵤ β)` of restriction to `S`, where `↥S →ᵤ β` is endowed with
the topology of uniform convergence. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_uniformity_of_basis_aux₁ {p : ι → Prop} {s : ι → Set (β × β)}
(hb : HasBasis (𝓤 β) p s) (S : Set α) :
(@uniformity (α →ᵤ[𝔖] β) ((UniformFun.uniformSpace S β).comap S.restrict)).HasBasis p fun i =>
UniformOnFun.gen 𝔖 S (s i) | by
simp_rw [UniformOnFun.gen_eq_preimage_restrict, uniformity_comap]
exact (UniformFun.hasBasis_uniformity_of_basis S β hb).comap _ | theorem | UniformOnFun.hasBasis_uniformity_of_basis_aux₁ | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.hasBasis_uniformity_of_basis",
"UniformFun.uniformSpace",
"UniformOnFun.gen",
"UniformOnFun.gen_eq_preimage_restrict",
"comap",
"uniformity",
"uniformity_comap"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
hasBasis_uniformity_of_basis_aux₂ (h : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop}
{s : ι → Set (β × β)} (hb : HasBasis (𝓤 β) p s) :
DirectedOn
((fun s : Set α => (UniformFun.uniformSpace s β).comap (s.restrict : (α →ᵤ β) → s →ᵤ β)) ⁻¹'o
GE.ge)
𝔖 | h.mono fun _ _ hst =>
((UniformOnFun.hasBasis_uniformity_of_basis_aux₁ α β 𝔖 hb _).le_basis_iff
(UniformOnFun.hasBasis_uniformity_of_basis_aux₁ α β 𝔖 hb _)).mpr
fun V hV => ⟨V, hV, UniformOnFun.gen_mono hst subset_rfl⟩ | theorem | UniformOnFun.hasBasis_uniformity_of_basis_aux₂ | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"DirectedOn",
"Set",
"UniformFun.uniformSpace",
"UniformOnFun.gen_mono",
"UniformOnFun.hasBasis_uniformity_of_basis_aux₁",
"comap"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
hasBasis_uniformity_of_basis (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖)
{p : ι → Prop} {s : ι → Set (β × β)} (hb : HasBasis (𝓤 β) p s) :
(𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
UniformOnFun.gen 𝔖 Si.1 (s Si.2) | by
simp only [iInf_uniformity]
exact
hasBasis_biInf_of_directed h (fun S => UniformOnFun.gen 𝔖 S ∘ s) _
(fun S _hS => UniformOnFun.hasBasis_uniformity_of_basis_aux₁ α β 𝔖 hb S)
(UniformOnFun.hasBasis_uniformity_of_basis_aux₂ α β 𝔖 h' hb) | theorem | UniformOnFun.hasBasis_uniformity_of_basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"DirectedOn",
"Set",
"UniformOnFun.gen",
"UniformOnFun.hasBasis_uniformity_of_basis_aux₁",
"UniformOnFun.hasBasis_uniformity_of_basis_aux₂",
"iInf_uniformity"
] | If `𝔖 : Set (Set α)` is nonempty and directed and `𝓑` is a filter basis of `𝓤 β`, then the
uniformity of `α →ᵤ[𝔖] β` admits the family `{(f, g) | ∀ x ∈ S, (f x, g x) ∈ V}` for `S ∈ 𝔖` and
`V ∈ 𝓑` as a filter basis. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_uniformity (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖) :
(𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun SV : Set α × Set (β × β) => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓤 β) fun SV =>
UniformOnFun.gen 𝔖 SV.1 SV.2 | UniformOnFun.hasBasis_uniformity_of_basis α β 𝔖 h h' (𝓤 β).basis_sets | theorem | UniformOnFun.hasBasis_uniformity | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"DirectedOn",
"Set",
"UniformOnFun.gen",
"UniformOnFun.hasBasis_uniformity_of_basis"
] | If `𝔖 : Set (Set α)` is nonempty and directed, then the uniformity of `α →ᵤ[𝔖] β` admits the
family `{(f, g) | ∀ x ∈ S, (f x, g x) ∈ V}` for `S ∈ 𝔖` and `V ∈ 𝓤 β` as a filter basis. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_uniformity_of_covering_of_basis {ι ι' : Type*} [Nonempty ι]
{t : ι → Set α} {p : ι' → Prop} {V : ι' → Set (β × β)} (ht : ∀ i, t i ∈ 𝔖)
(hdir : Directed (· ⊆ ·) t) (hex : ∀ s ∈ 𝔖, ∃ i, s ⊆ t i) (hb : HasBasis (𝓤 β) p V) :
(𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun i : ι × ι' ↦ p i.2) fun i ↦
UniformOn... | by
have hne : 𝔖.Nonempty := (range_nonempty t).mono (range_subset_iff.2 ht)
have hd : DirectedOn (· ⊆ ·) 𝔖 := fun s₁ hs₁ s₂ hs₂ ↦ by
rcases hex s₁ hs₁, hex s₂ hs₂ with ⟨⟨i₁, his₁⟩, i₂, his₂⟩
rcases hdir i₁ i₂ with ⟨i, hi₁, hi₂⟩
exact ⟨t i, ht _, his₁.trans hi₁, his₂.trans hi₂⟩
refine (UniformOnFun.h... | theorem | UniformOnFun.hasBasis_uniformity_of_covering_of_basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Directed",
"DirectedOn",
"Set",
"UniformOnFun.gen",
"UniformOnFun.gen_mono",
"UniformOnFun.hasBasis_uniformity_of_basis"
] | Let `t i` be a nonempty directed subfamily of `𝔖`
such that every `s ∈ 𝔖` is included in some `t i`.
Let `V` bounded by `p` be a basis of entourages of `β`.
Then `UniformOnFun.gen 𝔖 (t i) (V j)` bounded by `p j` is a basis of entourages of `α →ᵤ[𝔖] β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasAntitoneBasis_uniformity {ι : Type*} [Preorder ι] [IsDirectedOrder ι]
{t : ι → Set α} {V : ι → Set (β × β)}
(ht : ∀ n, t n ∈ 𝔖) (hmono : Monotone t) (hex : ∀ s ∈ 𝔖, ∃ n, s ⊆ t n)
(hb : HasAntitoneBasis (𝓤 β) V) :
(𝓤 (α →ᵤ[𝔖] β)).HasAntitoneBasis fun n ↦ UniformOnFun.gen 𝔖 (t n) (V n) | by
have := hb.nonempty
refine ⟨(UniformOnFun.hasBasis_uniformity_of_covering_of_basis 𝔖
ht hmono.directed_le hex hb.1).to_hasBasis ?_ fun i _ ↦ ⟨(i, i), trivial, Subset.rfl⟩, ?_⟩
· rintro ⟨k, l⟩ -
rcases directed_of (· ≤ ·) k l with ⟨n, hkn, hln⟩
exact ⟨n, trivial, UniformOnFun.gen_mono (hmono hkn) (... | theorem | UniformOnFun.hasAntitoneBasis_uniformity | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"IsDirectedOrder",
"Monotone",
"Preorder",
"Set",
"UniformOnFun.gen",
"UniformOnFun.gen_mono",
"UniformOnFun.hasBasis_uniformity_of_covering_of_basis",
"directed_of"
] | If `t n` is a monotone sequence of sets in `𝔖`
such that each `s ∈ 𝔖` is included in some `t n`
and `V n` is an antitone basis of entourages of `β`,
then `UniformOnFun.gen 𝔖 (t n) (V n)` is an antitone basis of entourages of `α →ᵤ[𝔖] β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isCountablyGenerated_uniformity [IsCountablyGenerated (𝓤 β)] {t : ℕ → Set α}
(ht : ∀ n, t n ∈ 𝔖) (hmono : Monotone t) (hex : ∀ s ∈ 𝔖, ∃ n, s ⊆ t n) :
IsCountablyGenerated (𝓤 (α →ᵤ[𝔖] β)) | let ⟨_V, hV⟩ := exists_antitone_basis (𝓤 β)
(UniformOnFun.hasAntitoneBasis_uniformity 𝔖 ht hmono hex hV).isCountablyGenerated | theorem | UniformOnFun.isCountablyGenerated_uniformity | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Monotone",
"Set",
"UniformOnFun.hasAntitoneBasis_uniformity"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
hasBasis_nhds_of_basis (f : α →ᵤ[𝔖] β) (h : 𝔖.Nonempty)
(h' : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {s : ι → Set (β × β)} (hb : HasBasis (𝓤 β) p s) :
(𝓝 f).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
{ g | (g, f) ∈ UniformOnFun.gen 𝔖 Si.1 (s Si.2) } | letI : UniformSpace (α → β) := UniformOnFun.uniformSpace α β 𝔖
nhds_basis_uniformity (UniformOnFun.hasBasis_uniformity_of_basis α β 𝔖 h h' hb) | theorem | UniformOnFun.hasBasis_nhds_of_basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"DirectedOn",
"Set",
"UniformOnFun.gen",
"UniformOnFun.hasBasis_uniformity_of_basis",
"UniformOnFun.uniformSpace",
"UniformSpace",
"nhds_basis_uniformity"
] | For `f : α →ᵤ[𝔖] β`, where `𝔖 : Set (Set α)` is nonempty and directed, `𝓝 f` admits the
family `{g | ∀ x ∈ S, (f x, g x) ∈ V}` for `S ∈ 𝔖` and `V ∈ 𝓑` as a filter basis, for any basis
`𝓑` of `𝓤 β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
hasBasis_nhds (f : α →ᵤ[𝔖] β) (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖) :
(𝓝 f).HasBasis (fun SV : Set α × Set (β × β) => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓤 β) fun SV =>
{ g | (g, f) ∈ UniformOnFun.gen 𝔖 SV.1 SV.2 } | UniformOnFun.hasBasis_nhds_of_basis α β 𝔖 f h h' (Filter.basis_sets _) | theorem | UniformOnFun.hasBasis_nhds | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"DirectedOn",
"Filter.basis_sets",
"Set",
"UniformOnFun.gen",
"UniformOnFun.hasBasis_nhds_of_basis"
] | For `f : α →ᵤ[𝔖] β`, where `𝔖 : Set (Set α)` is nonempty and directed, `𝓝 f` admits the
family `{g | ∀ x ∈ S, (f x, g x) ∈ V}` for `S ∈ 𝔖` and `V ∈ 𝓤 β` as a filter basis. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformContinuous_restrict (h : s ∈ 𝔖) :
UniformContinuous (UniformFun.ofFun ∘ (s.restrict : (α → β) → s → β) ∘ toFun 𝔖) | by
change _ ≤ _
simp only [map_le_iff_le_comap, iInf_uniformity]
exact iInf₂_le s h | theorem | UniformOnFun.uniformContinuous_restrict | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformContinuous",
"UniformFun.ofFun",
"iInf_uniformity"
] | If `S ∈ 𝔖`, then the restriction to `S` is a uniformly continuous map from `α →ᵤ[𝔖] β` to
`↥S →ᵤ β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
isUniformEmbedding_toFun_finite :
IsUniformEmbedding (toFun _ : (α →ᵤ[{s | s.Finite}] β) → (α → β)) | by
refine ⟨⟨?_⟩, Function.injective_id⟩
simp_rw [Pi.uniformity, comap_iInf, comap_comap]
refine HasBasis.ext (HasBasis.iInf' fun i ↦ (basis_sets _).comap _)
(UniformOnFun.hasBasis_uniformity α β _ ⟨∅, finite_empty⟩
(directedOn_of_sup_mem fun _ _ ↦ .union))
(fun ⟨S, U⟩ ⟨hS, hU⟩ ↦ ⟨⟨S, ⋂ x ∈ S, U x⟩, ... | theorem | UniformOnFun.isUniformEmbedding_toFun_finite | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"IsUniformEmbedding",
"Pi.uniformity",
"UniformOnFun.hasBasis_uniformity",
"comap",
"directedOn_of_sup_mem"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
isEmbedding_toFun_finite :
IsEmbedding (toFun _ : (α →ᵤ[{s | s.Finite}] β) → (α → β)) | (isUniformEmbedding_toFun_finite α β).isEmbedding | theorem | UniformOnFun.isEmbedding_toFun_finite | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
uniformity_eq_of_basis {ι : Sort*} {p : ι → Prop} {V : ι → Set (β × β)}
(h : (𝓤 β).HasBasis p V) :
𝓤 (α →ᵤ[𝔖] β) = ⨅ s ∈ 𝔖, ⨅ (i) (_ : p i), 𝓟 (UniformOnFun.gen 𝔖 s (V i)) | by
simp_rw [iInf_uniformity, uniformity_comap,
(UniformFun.hasBasis_uniformity_of_basis _ _ h).eq_biInf, comap_iInf, comap_principal,
Function.comp_apply, UniformFun.gen, Subtype.forall, UniformOnFun.gen, preimage_setOf_eq,
Prod.map_fst, Prod.map_snd, Function.comp_apply, UniformFun.toFun_ofFun, restrict_... | theorem | UniformOnFun.uniformity_eq_of_basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.gen",
"UniformFun.hasBasis_uniformity_of_basis",
"UniformFun.toFun_ofFun",
"UniformOnFun.gen",
"iInf_uniformity",
"uniformity_comap"
] | A version of `UniformOnFun.hasBasis_uniformity_of_basis`
with weaker conclusion and weaker assumptions.
We make no assumptions about the set `𝔖`
but conclude only that the uniformity is equal to some indexed infimum. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformity_eq : 𝓤 (α →ᵤ[𝔖] β) = ⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 (UniformOnFun.gen 𝔖 s V) | UniformOnFun.uniformity_eq_of_basis _ _ (𝓤 β).basis_sets | theorem | UniformOnFun.uniformity_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformOnFun.gen",
"UniformOnFun.uniformity_eq_of_basis"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
gen_mem_uniformity (hs : s ∈ 𝔖) {V : Set (β × β)} (hV : V ∈ 𝓤 β) :
UniformOnFun.gen 𝔖 s V ∈ 𝓤 (α →ᵤ[𝔖] β) | by
rw [UniformOnFun.uniformity_eq]
apply_rules [mem_iInf_of_mem, mem_principal_self] | theorem | UniformOnFun.gen_mem_uniformity | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformOnFun.gen",
"UniformOnFun.uniformity_eq"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
nhds_eq_of_basis {ι : Sort*} {p : ι → Prop} {V : ι → Set (β × β)}
(h : (𝓤 β).HasBasis p V) (f : α →ᵤ[𝔖] β) :
𝓝 f = ⨅ s ∈ 𝔖, ⨅ (i) (_ : p i), 𝓟 {g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V i} | by
simp_rw [nhds_eq_comap_uniformity, UniformOnFun.uniformity_eq_of_basis _ _ h, comap_iInf,
comap_principal, UniformOnFun.gen, preimage_setOf_eq] | theorem | UniformOnFun.nhds_eq_of_basis | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformOnFun.gen",
"UniformOnFun.uniformity_eq_of_basis",
"nhds_eq_comap_uniformity"
] | A version of `UniformOnFun.hasBasis_nhds_of_basis`
with weaker conclusion and weaker assumptions.
We make no assumptions about the set `𝔖`
but conclude only that the neighbourhoods filter is equal to some indexed infimum. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
nhds_eq (f : α →ᵤ[𝔖] β) :
𝓝 f = ⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 {g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V} | UniformOnFun.nhds_eq_of_basis _ _ (𝓤 β).basis_sets f | theorem | UniformOnFun.nhds_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformOnFun.nhds_eq_of_basis"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
gen_mem_nhds (f : α →ᵤ[𝔖] β) (hs : s ∈ 𝔖) {V : Set (β × β)} (hV : V ∈ 𝓤 β) :
{g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V} ∈ 𝓝 f | by
rw [UniformOnFun.nhds_eq]
apply_rules [mem_iInf_of_mem, mem_principal_self] | theorem | UniformOnFun.gen_mem_nhds | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformOnFun.nhds_eq"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
uniformContinuous_ofUniformFun :
UniformContinuous fun f : α →ᵤ β ↦ ofFun 𝔖 (UniformFun.toFun f) | by
simp only [UniformContinuous, UniformOnFun.uniformity_eq, tendsto_iInf, tendsto_principal,
(UniformFun.hasBasis_uniformity _ _).eventually_iff]
exact fun _ _ U hU ↦ ⟨U, hU, fun f hf x _ ↦ hf x⟩ | theorem | UniformOnFun.uniformContinuous_ofUniformFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformContinuous",
"UniformFun.hasBasis_uniformity",
"UniformFun.toFun",
"UniformOnFun.uniformity_eq"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
uniformEquivUniformFun (h : univ ∈ 𝔖) : (α →ᵤ[𝔖] β) ≃ᵤ (α →ᵤ β) | where
toFun f := UniformFun.ofFun <| toFun _ f
invFun f := ofFun _ <| UniformFun.toFun f
uniformContinuous_toFun := by
simp only [UniformContinuous, (UniformFun.hasBasis_uniformity _ _).tendsto_right_iff]
intro U hU
filter_upwards [UniformOnFun.gen_mem_uniformity _ _ h hU] with f hf x using hf x (mem_... | def | UniformOnFun.uniformEquivUniformFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformContinuous",
"UniformFun.hasBasis_uniformity",
"UniformFun.ofFun",
"UniformFun.toFun",
"UniformOnFun.gen_mem_uniformity"
] | The uniformity on `α →ᵤ[𝔖] β` is the same as the uniformity on `α →ᵤ β`,
provided that `Set.univ ∈ 𝔖`.
Here we formulate it as a `UniformEquiv`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformContinuous_ofFun_toFun (𝔗 : Set (Set α)) (h : ∀ s ∈ 𝔖, ∃ T ⊆ 𝔗, T.Finite ∧ s ⊆ ⋃₀ T) :
UniformContinuous (ofFun 𝔗 ∘ toFun 𝔖 : (α →ᵤ[𝔗] β) → α →ᵤ[𝔖] β) | by
simp only [UniformContinuous, UniformOnFun.uniformity_eq, iInf₂_comm (ι₂ := Set (β × β))]
refine tendsto_iInf_iInf fun V ↦ tendsto_iInf_iInf fun hV ↦ ?_
simp only [tendsto_iInf, tendsto_principal, Filter.Eventually, mem_biInf_principal]
intro s hs
obtain ⟨T, hT𝔗, hT, hsT⟩ := h s hs
refine ⟨T, hT, hT𝔗, ... | lemma | UniformOnFun.uniformContinuous_ofFun_toFun | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Filter.Eventually",
"Set",
"Set.mem_iInter",
"Set.mem_setOf_eq",
"UniformContinuous",
"UniformOnFun.gen",
"UniformOnFun.uniformity_eq"
] | If `𝔖` and `𝔗` are families of sets in `α`, then the identity map
`(α →ᵤ[𝔗] β) → (α →ᵤ[𝔖] β)` is uniformly continuous if every `s ∈ 𝔖` is contained in a finite
union of elements of `𝔗`.
With more API around `Order.Ideal`, this could be phrased in that language instead. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
mono ⦃u₁ u₂ : UniformSpace γ⦄ (hu : u₁ ≤ u₂) ⦃𝔖₁ 𝔖₂ : Set (Set α)⦄
(h𝔖 : 𝔖₂ ⊆ 𝔖₁) : 𝒱(α, γ, 𝔖₁, u₁) ≤ 𝒱(α, γ, 𝔖₂, u₂) | calc
𝒱(α, γ, 𝔖₁, u₁) ≤ 𝒱(α, γ, 𝔖₂, u₁) := iInf_le_iInf_of_subset h𝔖
_ ≤ 𝒱(α, γ, 𝔖₂, u₂) := iInf₂_mono fun _i _hi => UniformSpace.comap_mono <| UniformFun.mono hu | theorem | UniformOnFun.mono | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Set",
"UniformFun.mono",
"UniformSpace",
"UniformSpace.comap_mono"
] | Let `u₁`, `u₂` be two uniform structures on `γ` and `𝔖₁ 𝔖₂ : Set (Set α)`. If `u₁ ≤ u₂` and
`𝔖₂ ⊆ 𝔖₁` then `𝒱(α, γ, 𝔖₁, u₁) ≤ 𝒱(α, γ, 𝔖₂, u₂)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformContinuous_eval_of_mem {x : α} (hxs : x ∈ s) (hs : s ∈ 𝔖) :
UniformContinuous ((Function.eval x : (α → β) → β) ∘ toFun 𝔖) | (UniformFun.uniformContinuous_eval β (⟨x, hxs⟩ : s)).comp
(UniformOnFun.uniformContinuous_restrict α β 𝔖 hs) | theorem | UniformOnFun.uniformContinuous_eval_of_mem | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Function.eval",
"UniformContinuous",
"UniformFun.uniformContinuous_eval",
"UniformOnFun.uniformContinuous_restrict"
] | If `x : α` is in some `S ∈ 𝔖`, then evaluation at `x` is uniformly continuous on
`α →ᵤ[𝔖] β`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
uniformContinuous_eval_of_mem_sUnion {x : α} (hx : x ∈ ⋃₀ 𝔖) :
UniformContinuous ((Function.eval x : (α → β) → β) ∘ toFun 𝔖) | let ⟨_s, hs, hxs⟩ := hx
uniformContinuous_eval_of_mem _ _ hxs hs | theorem | UniformOnFun.uniformContinuous_eval_of_mem_sUnion | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Function.eval",
"UniformContinuous"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
uniformContinuous_eval (h : ⋃₀ 𝔖 = univ) (x : α) :
UniformContinuous ((Function.eval x : (α → β) → β) ∘ toFun 𝔖) | uniformContinuous_eval_of_mem_sUnion _ _ <| h.symm ▸ mem_univ _ | theorem | UniformOnFun.uniformContinuous_eval | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"Function.eval",
"UniformContinuous"
] | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 | |
iInf_eq {u : ι → UniformSpace γ} :
𝒱(α, γ, 𝔖, ⨅ i, u i) = ⨅ i, 𝒱(α, γ, 𝔖, u i) | by
simp_rw [UniformOnFun.uniformSpace, UniformFun.iInf_eq, UniformSpace.comap_iInf]
rw [iInf_comm]
exact iInf_congr fun s => iInf_comm | theorem | UniformOnFun.iInf_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.iInf_eq",
"UniformOnFun.uniformSpace",
"UniformSpace",
"UniformSpace.comap_iInf"
] | If `u` is a family of uniform structures on `γ`, then
`𝒱(α, γ, 𝔖, (⨅ i, u i)) = ⨅ i, 𝒱(α, γ, 𝔖, u i)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
inf_eq {u₁ u₂ : UniformSpace γ} :
𝒱(α, γ, 𝔖, u₁ ⊓ u₂) = 𝒱(α, γ, 𝔖, u₁) ⊓ 𝒱(α, γ, 𝔖, u₂) | by
rw [inf_eq_iInf, inf_eq_iInf, UniformOnFun.iInf_eq]
refine iInf_congr fun i => ?_
cases i <;> rfl | theorem | UniformOnFun.inf_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformOnFun.iInf_eq",
"UniformSpace"
] | If `u₁` and `u₂` are two uniform structures on `γ`, then
`𝒱(α, γ, 𝔖, u₁ ⊓ u₂) = 𝒱(α, γ, 𝔖, u₁) ⊓ 𝒱(α, γ, 𝔖, u₂)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
comap_eq {f : γ → β} :
𝒱(α, γ, 𝔖, ‹UniformSpace β›.comap f) = 𝒱(α, β, 𝔖, _).comap (f ∘ ·) | by
-- We reduce this to `UniformFun.comap_eq` using the fact that `comap` distributes
-- on `iInf`.
simp_rw [UniformOnFun.uniformSpace, UniformSpace.comap_iInf, UniformFun.comap_eq, ←
UniformSpace.comap_comap]
-- By definition, `∀ S ∈ 𝔖, (f ∘ —) ∘ S.restrict = S.restrict ∘ (f ∘ —)`.
rfl | theorem | UniformOnFun.comap_eq | Topology.UniformSpace | Mathlib/Topology/UniformSpace/UniformConvergenceTopology.lean | [] | [
"UniformFun.comap_eq",
"UniformOnFun.uniformSpace",
"UniformSpace.comap_comap",
"UniformSpace.comap_iInf",
"comap"
] | If `u` is a uniform structure on `β` and `f : γ → β`, then
`𝒱(α, γ, 𝔖, comap f u) = comap (fun g ↦ f ∘ g) 𝒱(α, γ, 𝔖, u₁)`. | https://github.com/leanprover-community/mathlib4 | b9f14353520df73472ae3825fb53f86559a01319 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.