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 ⌀ |
|---|---|---|---|---|---|---|
extend_comp_coe {f : hatα → β} (hf : UniformContinuous f) : pkg.extend (f ∘ ι) = f :=
funext fun x =>
pkg.induction_on x (isClosed_eq pkg.continuous_extend hf.continuous) fun y =>
pkg.extend_coe (hf.comp <| pkg.uniformContinuous_coe) y | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extend_comp_coe | null |
protected map (f : α → β) : hatα → hatβ :=
pkg.extend (ι' ∘ f)
local notation "map" => pkg.map pkg'
variable (f : α → β) | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | map | Lifting maps to completions |
uniformContinuous_map : UniformContinuous (map f) :=
pkg.uniformContinuous_extend
@[continuity] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_map | null |
continuous_map : Continuous (map f) :=
pkg.continuous_extend
variable {f}
@[simp] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | continuous_map | null |
map_coe (hf : UniformContinuous f) (a : α) : map f (ι a) = ι' (f a) :=
pkg.extend_coe (pkg'.uniformContinuous_coe.comp hf) a | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | map_coe | null |
map_unique {f : α → β} {g : hatα → hatβ} (hg : UniformContinuous g)
(h : ∀ a, ι' (f a) = g (ι a)) : map f = g :=
pkg.funext (pkg.continuous_map _ _) hg.continuous <| by
intro a
change pkg.extend (ι' ∘ f) _ = _
simp_rw [Function.comp_def, h, ← comp_apply (f := g)]
rw [pkg.extend_coe (hg.comp pkg.uniformContinuous_coe)]
@[simp] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | map_unique | null |
map_id : pkg.map pkg id = id :=
pkg.map_unique pkg uniformContinuous_id fun _ => rfl
variable {γ : Type uγ} [UniformSpace γ] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | map_id | null |
extend_map [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β}
(hf : UniformContinuous f) (hg : UniformContinuous g) :
pkg'.extend f ∘ map g = pkg.extend (f ∘ g) :=
pkg.funext (pkg'.continuous_extend.comp (pkg.continuous_map pkg' _)) pkg.continuous_extend
fun a => by
rw [pkg.extend_coe (hf.comp hg), comp_apply, pkg.map_coe pkg' hg, pkg'.extend_coe hf]
rfl
variable (pkg'' : AbstractCompletion.{vγ} γ) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extend_map | null |
map_comp {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f) :
pkg'.map pkg'' g ∘ pkg.map pkg' f = pkg.map pkg'' (g ∘ f) :=
pkg.extend_map pkg' (pkg''.uniformContinuous_coe.comp hg) hf | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | map_comp | null |
compare : pkg.space → pkg'.space :=
pkg.extend pkg'.coe | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | compare | The comparison map between two completions of the same uniform space. |
uniformContinuous_compare : UniformContinuous (pkg.compare pkg') :=
pkg.uniformContinuous_extend | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_compare | null |
compare_coe (a : α) : pkg.compare pkg' (pkg.coe a) = pkg'.coe a :=
pkg.extend_coe pkg'.uniformContinuous_coe a | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | compare_coe | null |
inverse_compare : pkg.compare pkg' ∘ pkg'.compare pkg = id := by
have uc := pkg.uniformContinuous_compare pkg'
have uc' := pkg'.uniformContinuous_compare pkg
apply pkg'.funext (uc.comp uc').continuous continuous_id
intro a
rw [comp_apply, pkg'.compare_coe pkg, pkg.compare_coe pkg']
rfl | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | inverse_compare | null |
compareEquiv : pkg.space ≃ᵤ pkg'.space where
toFun := pkg.compare pkg'
invFun := pkg'.compare pkg
left_inv := congr_fun (pkg'.inverse_compare pkg)
right_inv := congr_fun (pkg.inverse_compare pkg')
uniformContinuous_toFun := uniformContinuous_compare _ _
uniformContinuous_invFun := uniformContinuous_compare _ _ | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | compareEquiv | The uniform bijection between two completions of the same uniform space. |
uniformContinuous_compareEquiv : UniformContinuous (pkg.compareEquiv pkg') :=
pkg.uniformContinuous_compare pkg' | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_compareEquiv | null |
uniformContinuous_compareEquiv_symm : UniformContinuous (pkg.compareEquiv pkg').symm :=
pkg'.uniformContinuous_compare pkg
open scoped Topology
/-Let `f : α → γ` be a continuous function between a uniform space `α` and a regular topological
space `γ`, and let `pkg, pkg'` be two abstract completions of `α`. Then
if for every point `a : pkg` the filter `f.map (coe⁻¹ (𝓝 a))` obtained by pushing forward with `f`
the preimage in `α` of `𝓝 a` tends to `𝓝 (f.extend a : β)`, then the comparison map
between `pkg` and `pkg'` composed with the extension of `f` to `pkg`` coincides with the
extension of `f` to `pkg'`. The situation is described in the following diagram, where the
two diagonal arrows are the extensions of `f` to the two different completions `pkg` and `pkg'`;
the statement of `compare_comp_eq_compare` is the commutativity of the right triangle.
```
`α^`=`pkg` ≅ `α^'`=`pkg'` *here `≅` is `compare`*
∧ \ /
| \ /
| \ /
| V ∨
α ---f---> γ
```
-/ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_compareEquiv_symm | null |
compare_comp_eq_compare (γ : Type uγ) [TopologicalSpace γ]
[T3Space γ] {f : α → γ} (cont_f : Continuous f) :
letI := pkg.uniformStruct.toTopologicalSpace
letI := pkg'.uniformStruct.toTopologicalSpace
(∀ a : pkg.space,
Filter.Tendsto f (Filter.comap pkg.coe (𝓝 a)) (𝓝 ((pkg.isDenseInducing.extend f) a))) →
pkg.isDenseInducing.extend f ∘ pkg'.compare pkg = pkg'.isDenseInducing.extend f := by
let _ := pkg'.uniformStruct
let _ := pkg.uniformStruct
intro h
have (x : α) : (pkg.isDenseInducing.extend f ∘ pkg'.compare pkg) (pkg'.coe x) = f x := by
simp only [Function.comp_apply, compare_coe, IsDenseInducing.extend_eq _ cont_f]
apply (IsDenseInducing.extend_unique (AbstractCompletion.isDenseInducing _) this
(Continuous.comp _ (uniformContinuous_compare pkg' pkg).continuous )).symm
apply IsDenseInducing.continuous_extend
exact fun a ↦ ⟨(pkg.isDenseInducing.extend f) a, h a⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | compare_comp_eq_compare | null |
protected prod : AbstractCompletion (α × β) where
space := hatα × hatβ
coe p := ⟨ι p.1, ι' p.2⟩
uniformStruct := inferInstance
complete := inferInstance
separation := inferInstance
isUniformInducing := IsUniformInducing.prod pkg.isUniformInducing pkg'.isUniformInducing
dense := pkg.dense.prodMap pkg'.dense | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | prod | Products of completions |
protected extend₂ (f : α → β → γ) : hatα → hatβ → γ :=
curry <| (pkg.prod pkg').extend (uncurry f) | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extend₂ | Extend two variable map to completions. |
extension₂_coe_coe (hf : UniformContinuous <| uncurry f) (a : α) (b : β) :
pkg.extend₂ pkg' f (ι a) (ι' b) = f a b :=
show (pkg.prod pkg').extend (uncurry f) ((pkg.prod pkg').coe (a, b)) = uncurry f (a, b) from
(pkg.prod pkg').extend_coe hf _ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | extension₂_coe_coe | null |
uniformContinuous_extension₂ : UniformContinuous₂ (pkg.extend₂ pkg' f) := by
rw [uniformContinuous₂_def, AbstractCompletion.extend₂, uncurry_curry]
apply uniformContinuous_extend | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_extension₂ | null |
protected map₂ (f : α → β → γ) : hatα → hatβ → hatγ :=
pkg.extend₂ pkg' (pkg''.coe ∘₂ f) | def | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | map₂ | Lift two variable maps to completions. |
uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (pkg.map₂ pkg' pkg'' f) :=
AbstractCompletion.uniformContinuous_extension₂ pkg pkg' _ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | uniformContinuous_map₂ | null |
continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a : δ → hatα} {b : δ → hatβ}
(ha : Continuous a) (hb : Continuous b) :
Continuous fun d : δ => pkg.map₂ pkg' pkg'' f (a d) (b d) :=
(pkg.uniformContinuous_map₂ pkg' pkg'' f).continuous.comp₂ ha hb | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | continuous_map₂ | null |
map₂_coe_coe (a : α) (b : β) (f : α → β → γ) (hf : UniformContinuous₂ f) :
pkg.map₂ pkg' pkg'' f (ι a) (ι' b) = ι'' (f a b) :=
pkg.extension₂_coe_coe (f := pkg''.coe ∘₂ f) pkg' (pkg''.uniformContinuous_coe.comp hf) a b | theorem | Topology | [
"Mathlib.Topology.UniformSpace.UniformEmbedding",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/AbstractCompletion.lean | map₂_coe_coe | null |
Equicontinuous.comap_uniformFun_eq [CompactSpace X] (F_eqcont : Equicontinuous F) :
(UniformFun.uniformSpace X α).comap F =
(Pi.uniformSpace _).comap F := by
refine le_antisymm (UniformSpace.comap_mono UniformFun.uniformContinuous_toFun) ?_
simp_rw [UniformSpace.comap, UniformSpace.le_def, uniformity_comap, Pi.uniformity,
Filter.comap_iInf, comap_comap, Function.comp_def]
refine ((UniformFun.hasBasis_uniformity X α).comap (Prod.map F F)).ge_iff.mpr ?_
intro U hU
rcases comp_comp_symm_mem_uniformity_sets hU with ⟨V, hV, Vsymm, hVU⟩
let Ω x : Set X := {y | ∀ i, (F i x, F i y) ∈ V}
rcases CompactSpace.elim_nhds_subcover Ω (fun x ↦ F_eqcont x V hV) with ⟨A, Acover⟩
have : (⋂ a ∈ A, {ij : ι × ι | (F ij.1 a, F ij.2 a) ∈ V}) ⊆
(Prod.map F F) ⁻¹' UniformFun.gen X α U := by
rintro ⟨i, j⟩ hij x
rw [mem_iInter₂] at hij
rcases mem_iUnion₂.mp (Acover.symm.subset <| mem_univ x) with ⟨a, ha, hax⟩
exact hVU (prodMk_mem_compRel (prodMk_mem_compRel
(Vsymm.mk_mem_comm.mp (hax i)) (hij a ha)) (hax j))
exact mem_of_superset
(A.iInter_mem_sets.mpr fun x _ ↦ mem_iInf_of_mem x <| preimage_mem_comap hV) this | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | Equicontinuous.comap_uniformFun_eq | Let `X` be a compact topological space, `α` a uniform space, and `F : ι → (X → α)` an
equicontinuous family. Then, the uniform structures of uniform convergence and pointwise
convergence induce the same uniform structure on `ι`.
In other words, pointwise convergence and uniform convergence coincide on an equicontinuous
subset of `X → α`.
Consider using `Equicontinuous.isUniformInducing_uniformFun_iff_pi` and
`Equicontinuous.inducing_uniformFun_iff_pi` instead, to avoid rewriting instances. |
Equicontinuous.isUniformInducing_uniformFun_iff_pi [UniformSpace ι] [CompactSpace X]
(F_eqcont : Equicontinuous F) :
IsUniformInducing (UniformFun.ofFun ∘ F) ↔ IsUniformInducing F := by
rw [isUniformInducing_iff_uniformSpace, isUniformInducing_iff_uniformSpace,
← F_eqcont.comap_uniformFun_eq]
rfl | lemma | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | Equicontinuous.isUniformInducing_uniformFun_iff_pi | Let `X` be a compact topological space, `α` a uniform space, and `F : ι → (X → α)` an
equicontinuous family. Then, the uniform structures of uniform convergence and pointwise
convergence induce the same uniform structure on `ι`.
In other words, pointwise convergence and uniform convergence coincide on an equicontinuous
subset of `X → α`.
This is a version of `Equicontinuous.comap_uniformFun_eq` stated in terms of `IsUniformInducing`
for convenience. |
Equicontinuous.inducing_uniformFun_iff_pi [TopologicalSpace ι] [CompactSpace X]
(F_eqcont : Equicontinuous F) :
IsInducing (UniformFun.ofFun ∘ F) ↔ IsInducing F := by
rw [isInducing_iff, isInducing_iff]
change (_ = (UniformFun.uniformSpace X α |>.comap F |>.toTopologicalSpace)) ↔
(_ = (Pi.uniformSpace _ |>.comap F |>.toTopologicalSpace))
rw [F_eqcont.comap_uniformFun_eq] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | Equicontinuous.inducing_uniformFun_iff_pi | Let `X` be a compact topological space, `α` a uniform space, and `F : ι → (X → α)` an
equicontinuous family. Then, the topologies of uniform convergence and pointwise convergence induce
the same topology on `ι`.
In other words, pointwise convergence and uniform convergence coincide on an equicontinuous
subset of `X → α`.
This is a consequence of `Equicontinuous.comap_uniformFun_eq`, stated in terms of `IsInducing`
for convenience. |
Equicontinuous.tendsto_uniformFun_iff_pi [CompactSpace X]
(F_eqcont : Equicontinuous F) (ℱ : Filter ι) (f : X → α) :
Tendsto (UniformFun.ofFun ∘ F) ℱ (𝓝 <| UniformFun.ofFun f) ↔
Tendsto F ℱ (𝓝 f) := by
rcases ℱ.eq_or_neBot with rfl | ℱ_ne
· simp
constructor <;> intro H
· exact UniformFun.uniformContinuous_toFun.continuous.tendsto _|>.comp H
· set S : Set (X → α) := closure (range F)
set 𝒢 : Filter S := comap (↑) (map F ℱ)
have hS : S.Equicontinuous := closure' (by rwa [equicontinuous_iff_range] at F_eqcont)
continuous_id
have ind : IsInducing (UniformFun.ofFun ∘ (↑) : S → X →ᵤ α) :=
hS.inducing_uniformFun_iff_pi.mpr ⟨rfl⟩
have f_mem : f ∈ S := mem_closure_of_tendsto H range_mem_map
have h𝒢ℱ : map (↑) 𝒢 = map F ℱ := Filter.map_comap_of_mem
(Subtype.range_coe ▸ mem_of_superset range_mem_map subset_closure)
have H' : Tendsto id 𝒢 (𝓝 ⟨f, f_mem⟩) := by
rwa [tendsto_id', nhds_induced, ← map_le_iff_le_comap, h𝒢ℱ]
rwa [ind.tendsto_nhds_iff, comp_id, ← tendsto_map'_iff, h𝒢ℱ] at H' | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | Equicontinuous.tendsto_uniformFun_iff_pi | Let `X` be a compact topological space, `α` a uniform space, `F : ι → (X → α)` an
equicontinuous family, and `ℱ` a filter on `ι`. Then, `F` tends *uniformly* to `f : X → α` along
`ℱ` iff it tends to `f` *pointwise* along `ℱ`. |
EquicontinuousOn.comap_uniformOnFun_eq {𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
(UniformOnFun.uniformSpace X α 𝔖).comap F =
(Pi.uniformSpace _).comap ((⋃₀ 𝔖).restrict ∘ F) := by
have H1 : (UniformOnFun.uniformSpace X α 𝔖).comap F =
⨅ (K ∈ 𝔖), (UniformFun.uniformSpace _ _).comap (K.restrict ∘ F) := by
simp_rw [UniformOnFun.uniformSpace, UniformSpace.comap_iInf, ← UniformSpace.comap_comap,
UniformFun.ofFun, Equiv.coe_fn_mk, UniformOnFun.toFun, UniformOnFun.ofFun, Function.comp_def,
UniformFun, Equiv.coe_fn_symm_mk]
have H2 : (Pi.uniformSpace _).comap ((⋃₀ 𝔖).restrict ∘ F) =
⨅ (K ∈ 𝔖), (Pi.uniformSpace _).comap (K.restrict ∘ F) := by
simp_rw [UniformSpace.comap_comap, Pi.uniformSpace_comap_restrict_sUnion (fun _ ↦ α) 𝔖,
UniformSpace.comap_iInf]
have H3 : ∀ K ∈ 𝔖, (UniformFun.uniformSpace K α).comap (K.restrict ∘ F) =
(Pi.uniformSpace _).comap (K.restrict ∘ F) := fun K hK ↦ by
have : CompactSpace K := isCompact_iff_compactSpace.mp (𝔖_compact K hK)
exact (equicontinuous_restrict_iff _ |>.mpr <| F_eqcont K hK).comap_uniformFun_eq
simp_rw [H1, H2, iInf_congr fun K ↦ iInf_congr fun hK ↦ H3 K hK] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.comap_uniformOnFun_eq | Let `X` be a topological space, `𝔖` a family of compact subsets of `X`, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the uniform
structures of uniform convergence on `𝔖` and pointwise convergence on `⋃₀ 𝔖` induce the same
uniform structure on `ι`.
In particular, pointwise convergence and compact convergence coincide on an equicontinuous
subset of `X → α`.
Consider using `EquicontinuousOn.isUniformInducing_uniformOnFun_iff_pi'` and
`EquicontinuousOn.inducing_uniformOnFun_iff_pi'` instead to avoid rewriting instances,
as well as their unprimed versions in case `𝔖` covers `X`. |
EquicontinuousOn.isUniformInducing_uniformOnFun_iff_pi' [UniformSpace ι]
{𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
IsUniformInducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
IsUniformInducing ((⋃₀ 𝔖).restrict ∘ F) := by
rw [isUniformInducing_iff_uniformSpace, isUniformInducing_iff_uniformSpace,
← EquicontinuousOn.comap_uniformOnFun_eq 𝔖_compact F_eqcont]
rfl | lemma | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.isUniformInducing_uniformOnFun_iff_pi' | Let `X` be a topological space, `𝔖` a family of compact subsets of `X`, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the uniform
structures of uniform convergence on `𝔖` and pointwise convergence on `⋃₀ 𝔖` induce the same
uniform structure on `ι`.
In particular, pointwise convergence and compact convergence coincide on an equicontinuous
subset of `X → α`.
This is a version of `EquicontinuousOn.comap_uniformOnFun_eq` stated in terms of `IsUniformInducing`
for convenience. |
EquicontinuousOn.isUniformInducing_uniformOnFun_iff_pi [UniformSpace ι]
{𝔖 : Set (Set X)} (𝔖_covers : ⋃₀ 𝔖 = univ) (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
IsUniformInducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
IsUniformInducing F := by
rw [eq_univ_iff_forall] at 𝔖_covers
let φ : ((⋃₀ 𝔖) → α) ≃ᵤ (X → α) := UniformEquiv.piCongrLeft (β := fun _ ↦ α)
(Equiv.subtypeUnivEquiv 𝔖_covers)
rw [EquicontinuousOn.isUniformInducing_uniformOnFun_iff_pi' 𝔖_compact F_eqcont,
show restrict (⋃₀ 𝔖) ∘ F = φ.symm ∘ F by rfl]
exact ⟨fun H ↦ φ.isUniformInducing.comp H, fun H ↦ φ.symm.isUniformInducing.comp H⟩ | lemma | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.isUniformInducing_uniformOnFun_iff_pi | Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the uniform
structures of uniform convergence on `𝔖` and pointwise convergence induce the same
uniform structure on `ι`.
This is a specialization of `EquicontinuousOn.isUniformInducing_uniformOnFun_iff_pi'` to
the case where `𝔖` covers `X`. |
EquicontinuousOn.inducing_uniformOnFun_iff_pi' [TopologicalSpace ι]
{𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
IsInducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
IsInducing ((⋃₀ 𝔖).restrict ∘ F) := by
rw [isInducing_iff, isInducing_iff]
change (_ = ((UniformOnFun.uniformSpace X α 𝔖).comap F).toTopologicalSpace) ↔
(_ = ((Pi.uniformSpace _).comap ((⋃₀ 𝔖).restrict ∘ F)).toTopologicalSpace)
rw [← EquicontinuousOn.comap_uniformOnFun_eq 𝔖_compact F_eqcont] | lemma | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.inducing_uniformOnFun_iff_pi' | Let `X` be a topological space, `𝔖` a family of compact subsets of `X`, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the topologies
of uniform convergence on `𝔖` and pointwise convergence on `⋃₀ 𝔖` induce the same topology on `ι`.
In particular, pointwise convergence and compact convergence coincide on an equicontinuous
subset of `X → α`.
This is a consequence of `EquicontinuousOn.comap_uniformOnFun_eq` stated in terms of `IsInducing`
for convenience. |
EquicontinuousOn.isInducing_uniformOnFun_iff_pi [TopologicalSpace ι]
{𝔖 : Set (Set X)} (𝔖_covers : ⋃₀ 𝔖 = univ) (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
IsInducing (UniformOnFun.ofFun 𝔖 ∘ F) ↔
IsInducing F := by
rw [eq_univ_iff_forall] at 𝔖_covers
let φ : ((⋃₀ 𝔖) → α) ≃ₜ (X → α) := Homeomorph.piCongrLeft (Y := fun _ ↦ α)
(Equiv.subtypeUnivEquiv 𝔖_covers)
rw [EquicontinuousOn.inducing_uniformOnFun_iff_pi' 𝔖_compact F_eqcont,
show restrict (⋃₀ 𝔖) ∘ F = φ.symm ∘ F by rfl]
exact ⟨fun H ↦ φ.isInducing.comp H, fun H ↦ φ.symm.isInducing.comp H⟩ | lemma | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.isInducing_uniformOnFun_iff_pi | Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)` a family which is equicontinuous on each `K ∈ 𝔖`. Then, the topologies
of uniform convergence on `𝔖` and pointwise convergence induce the same topology on `ι`.
This is a specialization of `EquicontinuousOn.inducing_uniformOnFun_iff_pi'` to
the case where `𝔖` covers `X`. |
EquicontinuousOn.tendsto_uniformOnFun_iff_pi'
{𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) (ℱ : Filter ι) (f : X → α) :
Tendsto (UniformOnFun.ofFun 𝔖 ∘ F) ℱ (𝓝 <| UniformOnFun.ofFun 𝔖 f) ↔
Tendsto ((⋃₀ 𝔖).restrict ∘ F) ℱ (𝓝 <| (⋃₀ 𝔖).restrict f) := by
rw [← Filter.tendsto_comap_iff (g := (⋃₀ 𝔖).restrict), ← nhds_induced]
simp_rw [UniformOnFun.topologicalSpace_eq, Pi.induced_restrict_sUnion 𝔖 (A := fun _ ↦ α),
_root_.nhds_iInf, nhds_induced, tendsto_iInf, tendsto_comap_iff]
congrm ∀ K (hK : K ∈ 𝔖), ?_
have : CompactSpace K := isCompact_iff_compactSpace.mp (𝔖_compact K hK)
rw [← (equicontinuous_restrict_iff _ |>.mpr <| F_eqcont K hK).tendsto_uniformFun_iff_pi]
rfl | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.tendsto_uniformOnFun_iff_pi' | Let `X` be a topological space, `𝔖` a family of compact subsets of `X`,
`α` a uniform space, `F : ι → (X → α)` a family equicontinuous on each `K ∈ 𝔖`, and `ℱ` a filter
on `ι`. Then, `F` tends to `f : X → α` along `ℱ` *uniformly on each `K ∈ 𝔖`* iff it tends to `f`
*pointwise on `⋃₀ 𝔖`* along `ℱ`. |
EquicontinuousOn.tendsto_uniformOnFun_iff_pi
{𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K) (𝔖_covers : ⋃₀ 𝔖 = univ)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) (ℱ : Filter ι) (f : X → α) :
Tendsto (UniformOnFun.ofFun 𝔖 ∘ F) ℱ (𝓝 <| UniformOnFun.ofFun 𝔖 f) ↔
Tendsto F ℱ (𝓝 f) := by
rw [eq_univ_iff_forall] at 𝔖_covers
let φ : ((⋃₀ 𝔖) → α) ≃ₜ (X → α) := Homeomorph.piCongrLeft (Y := fun _ ↦ α)
(Equiv.subtypeUnivEquiv 𝔖_covers)
rw [EquicontinuousOn.tendsto_uniformOnFun_iff_pi' 𝔖_compact F_eqcont,
show restrict (⋃₀ 𝔖) ∘ F = φ.symm ∘ F by rfl, show restrict (⋃₀ 𝔖) f = φ.symm f by rfl,
φ.symm.isInducing.tendsto_nhds_iff] | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.tendsto_uniformOnFun_iff_pi | Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets,
`α` a uniform space, `F : ι → (X → α)` a family equicontinuous on each `K ∈ 𝔖`, and `ℱ` a filter
on `ι`. Then, `F` tends to `f : X → α` along `ℱ` *uniformly on each `K ∈ 𝔖`* iff it tends to `f`
*pointwise* along `ℱ`.
This is a specialization of `EquicontinuousOn.tendsto_uniformOnFun_iff_pi'` to the case
where `𝔖` covers `X`. |
EquicontinuousOn.isClosed_range_pi_of_uniformOnFun'
{𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K)
(H : IsClosed (range <| UniformOnFun.ofFun 𝔖 ∘ F)) :
IsClosed (range <| (⋃₀ 𝔖).restrict ∘ F) := by
rcases isEmpty_or_nonempty α with _ | _
· simp [isClosed_discrete]
simp_rw [isClosed_iff_clusterPt, ← Filter.map_top, ← mapClusterPt_def,
mapClusterPt_iff_ultrafilter, range_comp, Subtype.coe_injective.surjective_comp_right.forall,
← restrict_eq, ← EquicontinuousOn.tendsto_uniformOnFun_iff_pi' 𝔖_compact F_eqcont]
exact fun f ⟨u, _, hu⟩ ↦ mem_image_of_mem _ <| H.mem_of_tendsto hu <|
Eventually.of_forall mem_range_self | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.isClosed_range_pi_of_uniformOnFun' | Let `X` be a topological space, `𝔖` a family of compact subsets of `X` and
`α` a uniform space. An equicontinuous subset of `X → α` is closed in the topology of uniform
convergence on all `K ∈ 𝔖` iff it is closed in the topology of pointwise convergence on `⋃₀ 𝔖`. |
EquicontinuousOn.isClosed_range_uniformOnFun_iff_pi
{𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K) (𝔖_covers : ⋃₀ 𝔖 = univ)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K) :
IsClosed (range <| UniformOnFun.ofFun 𝔖 ∘ F) ↔
IsClosed (range F) := by
simp_rw [isClosed_iff_clusterPt, ← Filter.map_top, ← mapClusterPt_def,
mapClusterPt_iff_ultrafilter, range_comp, (UniformOnFun.ofFun 𝔖).surjective.forall,
← EquicontinuousOn.tendsto_uniformOnFun_iff_pi 𝔖_compact 𝔖_covers F_eqcont,
(UniformOnFun.ofFun 𝔖).injective.mem_set_image]
alias ⟨EquicontinuousOn.isClosed_range_pi_of_uniformOnFun, _⟩ :=
EquicontinuousOn.isClosed_range_uniformOnFun_iff_pi | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | EquicontinuousOn.isClosed_range_uniformOnFun_iff_pi | Let `X` be a topological space, `𝔖` a covering of `X` by compact subsets, and
`α` a uniform space. An equicontinuous subset of `X → α` is closed in the topology of uniform
convergence on all `K ∈ 𝔖` iff it is closed in the topology of pointwise convergence.
This is a specialization of `EquicontinuousOn.isClosed_range_pi_of_uniformOnFun'` to the case where
`𝔖` covers `X`. |
ArzelaAscoli.compactSpace_of_closed_inducing' [TopologicalSpace ι] {𝔖 : Set (Set X)}
(𝔖_compact : ∀ K ∈ 𝔖, IsCompact K) (F_ind : IsInducing (UniformOnFun.ofFun 𝔖 ∘ F))
(F_cl : IsClosed <| range <| UniformOnFun.ofFun 𝔖 ∘ F)
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K)
(F_pointwiseCompact : ∀ K ∈ 𝔖, ∀ x ∈ K, ∃ Q, IsCompact Q ∧ ∀ i, F i x ∈ Q) :
CompactSpace ι := by
have : IsInducing (restrict (⋃₀ 𝔖) ∘ F) := by
rwa [EquicontinuousOn.inducing_uniformOnFun_iff_pi' 𝔖_compact F_eqcont] at F_ind
rw [← isCompact_univ_iff, this.isCompact_iff, image_univ]
rw [← forall_sUnion] at F_pointwiseCompact
choose! Q Q_compact F_in_Q using F_pointwiseCompact
refine IsCompact.of_isClosed_subset (isCompact_univ_pi fun x ↦ Q_compact x x.2)
(EquicontinuousOn.isClosed_range_pi_of_uniformOnFun' 𝔖_compact F_eqcont F_cl)
(range_subset_iff.mpr fun i x _ ↦ F_in_Q x x.2 i) | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | ArzelaAscoli.compactSpace_of_closed_inducing' | A version of the **Arzela-Ascoli theorem**.
Let `X` be a topological space, `𝔖` a family of compact subsets of `X`, `α` a uniform space,
and `F : ι → (X → α)`. Assume that:
* `F`, viewed as a function `ι → (X →ᵤ[𝔖] α)`, is closed and inducing
* `F` is equicontinuous on each `K ∈ 𝔖`
* For all `x ∈ ⋃₀ 𝔖`, the range of `i ↦ F i x` is contained in some fixed compact subset.
Then `ι` is compact. |
ArzelaAscoli.compactSpace_of_isClosedEmbedding [TopologicalSpace ι] {𝔖 : Set (Set X)}
(𝔖_compact : ∀ K ∈ 𝔖, IsCompact K) (F_clemb : IsClosedEmbedding (UniformOnFun.ofFun 𝔖 ∘ F))
(F_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn F K)
(F_pointwiseCompact : ∀ K ∈ 𝔖, ∀ x ∈ K, ∃ Q, IsCompact Q ∧ ∀ i, F i x ∈ Q) :
CompactSpace ι :=
compactSpace_of_closed_inducing' 𝔖_compact F_clemb.isInducing F_clemb.isClosed_range
F_eqcont F_pointwiseCompact | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | ArzelaAscoli.compactSpace_of_isClosedEmbedding | A version of the **Arzela-Ascoli theorem**.
Let `X, ι` be topological spaces, `𝔖` a covering of `X` by compact subsets, `α` a uniform space,
and `F : ι → (X → α)`. Assume that:
* `F`, viewed as a function `ι → (X →ᵤ[𝔖] α)`, is a closed embedding (in other words, `ι`
identifies to a closed subset of `X →ᵤ[𝔖] α` through `F`)
* `F` is equicontinuous on each `K ∈ 𝔖`
* For all `x`, the range of `i ↦ F i x` is contained in some fixed compact subset.
Then `ι` is compact. |
ArzelaAscoli.isCompact_closure_of_isClosedEmbedding [TopologicalSpace ι] [T2Space α]
{𝔖 : Set (Set X)} (𝔖_compact : ∀ K ∈ 𝔖, IsCompact K)
(F_clemb : IsClosedEmbedding (UniformOnFun.ofFun 𝔖 ∘ F))
{s : Set ι} (s_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn (F ∘ ((↑) : s → ι)) K)
(s_pointwiseCompact : ∀ K ∈ 𝔖, ∀ x ∈ K, ∃ Q, IsCompact Q ∧ ∀ i ∈ s, F i x ∈ Q) :
IsCompact (closure s) := by
rw [isCompact_iff_compactSpace]
have : ∀ K ∈ 𝔖, ∀ x ∈ K, Continuous (eval x ∘ F) := fun K hK x hx ↦
UniformOnFun.uniformContinuous_eval_of_mem _ _ hx hK |>.continuous.comp F_clemb.continuous
have cls_eqcont : ∀ K ∈ 𝔖, EquicontinuousOn (F ∘ ((↑) : closure s → ι)) K :=
fun K hK ↦ (s_eqcont K hK).closure' <| show Continuous (K.restrict ∘ F) from
continuous_pi fun ⟨x, hx⟩ ↦ this K hK x hx
have cls_pointwiseCompact : ∀ K ∈ 𝔖, ∀ x ∈ K, ∃ Q, IsCompact Q ∧ ∀ i ∈ closure s, F i x ∈ Q :=
fun K hK x hx ↦ (s_pointwiseCompact K hK x hx).imp fun Q hQ ↦ ⟨hQ.1, closure_minimal hQ.2 <|
hQ.1.isClosed.preimage (this K hK x hx)⟩
exact ArzelaAscoli.compactSpace_of_isClosedEmbedding 𝔖_compact
(F_clemb.comp isClosed_closure.isClosedEmbedding_subtypeVal) cls_eqcont
fun K hK x hx ↦ (cls_pointwiseCompact K hK x hx).imp fun Q hQ ↦ ⟨hQ.1, by simpa using hQ.2⟩ | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | ArzelaAscoli.isCompact_closure_of_isClosedEmbedding | A version of the **Arzela-Ascoli theorem**.
Let `X, ι` be topological spaces, `𝔖` a covering of `X` by compact subsets, `α` a T2 uniform space,
`F : ι → (X → α)`, and `s` a subset of `ι`. Assume that:
* `F`, viewed as a function `ι → (X →ᵤ[𝔖] α)`, is a closed embedding (in other words, `ι`
identifies to a closed subset of `X →ᵤ[𝔖] α` through `F`)
* `F '' s` is equicontinuous on each `K ∈ 𝔖`
* For all `x ∈ ⋃₀ 𝔖`, the image of `s` under `i ↦ F i x` is contained in some fixed compact subset.
Then `s` has compact closure in `ι`. |
ArzelaAscoli.isCompact_of_equicontinuous
(S : Set C(X, α)) (hS1 : IsCompact (ContinuousMap.toFun '' S))
(hS2 : Equicontinuous ((↑) : S → X → α)) : IsCompact S := by
suffices h : IsInducing (Equiv.Set.image _ S DFunLike.coe_injective) by
rw [isCompact_iff_compactSpace] at hS1 ⊢
exact (Equiv.toHomeomorphOfIsInducing _ h).symm.compactSpace
rw [← IsInducing.subtypeVal.of_comp_iff, ← EquicontinuousOn.isInducing_uniformOnFun_iff_pi _ _ _]
· exact ContinuousMap.isUniformEmbedding_toUniformOnFunIsCompact.isInducing.comp .subtypeVal
· exact eq_univ_iff_forall.mpr (fun x ↦ mem_sUnion_of_mem (mem_singleton x) isCompact_singleton)
· exact fun _ ↦ id
· exact fun K _ ↦ hS2.equicontinuousOn K | theorem | Topology | [
"Mathlib.Topology.UniformSpace.CompactConvergence",
"Mathlib.Topology.UniformSpace.Equicontinuity",
"Mathlib.Topology.UniformSpace.Equiv"
] | Mathlib/Topology/UniformSpace/Ascoli.lean | ArzelaAscoli.isCompact_of_equicontinuous | A version of the **Arzela-Ascoli theorem**.
If an equicontinuous family of continuous functions is compact in the pointwise topology, then it
is compact in the compact open topology. |
IsOpen.relComp [TopologicalSpace α] [TopologicalSpace β] [TopologicalSpace γ]
{s : SetRel α β} {t : SetRel β γ} (hs : IsOpen s) (ht : IsOpen t) : IsOpen (s ○ t) := by
conv =>
arg 1; equals ⋃ b, (fun p => (p.1, b)) ⁻¹' s ∩ (fun p => (b, p.2)) ⁻¹' t => ext ⟨_, _⟩; simp
exact isOpen_iUnion fun a ↦ hs.preimage (by fun_prop) |>.inter <| ht.preimage (by fun_prop) | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | IsOpen.relComp | null |
eventually_uniformity_iterate_comp_subset {s : Set (α × α)} (hs : s ∈ 𝓤 α) (n : ℕ) :
∀ᶠ t in (𝓤 α).smallSets, (t ○ ·)^[n] t ⊆ s := by
suffices ∀ᶠ t in (𝓤 α).smallSets, t ⊆ s ∧ (t ○ ·)^[n] t ⊆ s from (eventually_and.1 this).2
induction n generalizing s with
| zero => simpa
| succ _ ihn =>
rcases comp_mem_uniformity_sets hs with ⟨t, htU, hts⟩
refine (ihn htU).mono fun U hU => ?_
rw [Function.iterate_succ_apply']
exact
⟨hU.1.trans <| (subset_comp_self <| refl_le_uniformity htU).trans hts,
(compRel_mono hU.1 hU.2).trans hts⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | eventually_uniformity_iterate_comp_subset | If `s ∈ 𝓤 α`, then for any natural `n`, for a subset `t` of a sufficiently small set in `𝓤 α`,
we have `t ○ t ○ ... ○ t ⊆ s` (`n` compositions). |
eventually_uniformity_comp_subset {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
∀ᶠ t in (𝓤 α).smallSets, t ○ t ⊆ s :=
eventually_uniformity_iterate_comp_subset hs 1
/-! | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | eventually_uniformity_comp_subset | If `s ∈ 𝓤 α`, then for a subset `t` of a sufficiently small set in `𝓤 α`,
we have `t ○ t ⊆ s`. |
isOpen_ball (x : α) {V : Set (α × α)} (hV : IsOpen V) : IsOpen (ball x V) :=
hV.preimage <| .prodMk_right _ | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | isOpen_ball | null |
isClosed_ball (x : α) {V : Set (α × α)} (hV : IsClosed V) : IsClosed (ball x V) :=
hV.preimage <| .prodMk_right _
/-! | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | isClosed_ball | null |
hasBasis_nhds_prod (x y : α) :
HasBasis (𝓝 (x, y)) (fun s => s ∈ 𝓤 α ∧ IsSymmetricRel s) fun s => ball x s ×ˢ ball y s := by
rw [nhds_prod_eq]
apply (hasBasis_nhds x).prod_same_index (hasBasis_nhds y)
rintro U V ⟨U_in, U_symm⟩ ⟨V_in, V_symm⟩
exact
⟨U ∩ V, ⟨(𝓤 α).inter_sets U_in V_in, U_symm.inter V_symm⟩, ball_inter_left x U V,
ball_inter_right y U V⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | hasBasis_nhds_prod | null |
nhds_eq_uniformity_prod {a b : α} :
𝓝 (a, b) =
(𝓤 α).lift' fun s : Set (α × α) => { y : α | (y, a) ∈ s } ×ˢ { y : α | (b, y) ∈ s } := by
rw [nhds_prod_eq, nhds_nhds_eq_uniformity_uniformity_prod, lift_lift'_same_eq_lift']
· exact fun s => monotone_const.set_prod monotone_preimage
· refine fun t => Monotone.set_prod ?_ monotone_const
exact monotone_preimage (f := fun y => (y, a)) | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | nhds_eq_uniformity_prod | null |
nhdset_of_mem_uniformity {d : Set (α × α)} (s : Set (α × α)) (hd : d ∈ 𝓤 α) :
∃ t : Set (α × α), IsOpen t ∧ s ⊆ t ∧
t ⊆ { p | ∃ x y, (p.1, x) ∈ d ∧ (x, y) ∈ s ∧ (y, p.2) ∈ d } := by
let cl_d := { p : α × α | ∃ x y, (p.1, x) ∈ d ∧ (x, y) ∈ s ∧ (y, p.2) ∈ d }
have : ∀ p ∈ s, ∃ t, t ⊆ cl_d ∧ IsOpen t ∧ p ∈ t := fun ⟨x, y⟩ hp =>
mem_nhds_iff.mp <|
show cl_d ∈ 𝓝 (x, y) by
rw [nhds_eq_uniformity_prod, mem_lift'_sets]
· exact ⟨d, hd, fun ⟨a, b⟩ ⟨ha, hb⟩ => ⟨x, y, ha, hp, hb⟩⟩
· exact fun _ _ h _ h' => ⟨h h'.1, h h'.2⟩
choose t ht using this
exact ⟨(⋃ p : α × α, ⋃ h : p ∈ s, t p h : Set (α × α)),
isOpen_iUnion fun p : α × α => isOpen_iUnion fun hp => (ht p hp).right.left,
fun ⟨a, b⟩ hp => by
simp only [mem_iUnion, Prod.exists]; exact ⟨a, b, hp, (ht (a, b) hp).right.right⟩,
iUnion_subset fun p => iUnion_subset fun hp => (ht p hp).left⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | nhdset_of_mem_uniformity | null |
nhds_le_uniformity (x : α) : 𝓝 (x, x) ≤ 𝓤 α := by
intro V V_in
rcases comp_symm_mem_uniformity_sets V_in with ⟨w, w_in, w_symm, w_sub⟩
have : ball x w ×ˢ ball x w ∈ 𝓝 (x, x) := by
rw [nhds_prod_eq]
exact prod_mem_prod (ball_mem_nhds x w_in) (ball_mem_nhds x w_in)
apply mem_of_superset this
rintro ⟨u, v⟩ ⟨u_in, v_in⟩
exact w_sub (mem_comp_of_mem_ball w_symm u_in v_in) | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | nhds_le_uniformity | Entourages are neighborhoods of the diagonal. |
iSup_nhds_le_uniformity : ⨆ x : α, 𝓝 (x, x) ≤ 𝓤 α :=
iSup_le nhds_le_uniformity | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | iSup_nhds_le_uniformity | Entourages are neighborhoods of the diagonal. |
nhdsSet_diagonal_le_uniformity : 𝓝ˢ (diagonal α) ≤ 𝓤 α :=
(nhdsSet_diagonal α).trans_le iSup_nhds_le_uniformity | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | nhdsSet_diagonal_le_uniformity | Entourages are neighborhoods of the diagonal. |
UniformSpace.has_seq_basis [IsCountablyGenerated <| 𝓤 α] :
∃ V : ℕ → Set (α × α), HasAntitoneBasis (𝓤 α) V ∧ ∀ n, IsSymmetricRel (V n) :=
let ⟨U, hsym, hbasis⟩ := (@UniformSpace.hasBasis_symmetric α _).exists_antitone_subbasis
⟨U, hbasis, fun n => (hsym n).2⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.has_seq_basis | null |
closure_eq_uniformity (s : Set <| α × α) :
closure s = ⋂ V ∈ { V | V ∈ 𝓤 α ∧ IsSymmetricRel V }, V ○ s ○ V := by
ext ⟨x, y⟩
simp +contextual only
[mem_closure_iff_nhds_basis (UniformSpace.hasBasis_nhds_prod x y), mem_iInter, mem_setOf_eq,
and_imp, mem_comp_comp, ← mem_inter_iff, inter_comm, Set.Nonempty] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | closure_eq_uniformity | null |
uniformity_hasBasis_closed :
HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α ∧ IsClosed V) id := by
refine Filter.hasBasis_self.2 fun t h => ?_
rcases comp_comp_symm_mem_uniformity_sets h with ⟨w, w_in, w_symm, r⟩
refine ⟨closure w, mem_of_superset w_in subset_closure, isClosed_closure, ?_⟩
refine Subset.trans ?_ r
rw [closure_eq_uniformity]
apply iInter_subset_of_subset
apply iInter_subset
exact ⟨w_in, w_symm⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformity_hasBasis_closed | null |
uniformity_eq_uniformity_closure : 𝓤 α = (𝓤 α).lift' closure :=
Eq.symm <| uniformity_hasBasis_closed.lift'_closure_eq_self fun _ => And.right | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformity_eq_uniformity_closure | null |
Filter.HasBasis.uniformity_closure {p : ι → Prop} {U : ι → Set (α × α)}
(h : (𝓤 α).HasBasis p U) : (𝓤 α).HasBasis p fun i => closure (U i) :=
(@uniformity_eq_uniformity_closure α _).symm ▸ h.lift'_closure | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | Filter.HasBasis.uniformity_closure | null |
uniformity_hasBasis_closure : HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α) closure :=
(𝓤 α).basis_sets.uniformity_closure | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformity_hasBasis_closure | Closed entourages form a basis of the uniformity filter. |
closure_eq_inter_uniformity {t : Set (α × α)} : closure t = ⋂ d ∈ 𝓤 α, d ○ (t ○ d) :=
calc
closure t = ⋂ (V) (_ : V ∈ 𝓤 α ∧ IsSymmetricRel V), V ○ t ○ V := closure_eq_uniformity t
_ = ⋂ V ∈ 𝓤 α, V ○ t ○ V :=
Eq.symm <|
UniformSpace.hasBasis_symmetric.biInter_mem fun _ _ hV =>
compRel_mono (compRel_mono hV Subset.rfl) hV
_ = ⋂ V ∈ 𝓤 α, V ○ (t ○ V) := by simp only [compRel_assoc] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | closure_eq_inter_uniformity | null |
uniformity_eq_uniformity_interior : 𝓤 α = (𝓤 α).lift' interior :=
le_antisymm
(le_iInf₂ fun d hd => by
let ⟨s, hs, hs_comp⟩ := comp3_mem_uniformity hd
let ⟨t, ht, hst, ht_comp⟩ := nhdset_of_mem_uniformity s hs
have : s ⊆ interior d :=
calc
s ⊆ t := hst
_ ⊆ interior d :=
ht.subset_interior_iff.mpr fun x (hx : x ∈ t) =>
let ⟨x, y, h₁, h₂, h₃⟩ := ht_comp hx
hs_comp ⟨x, h₁, y, h₂, h₃⟩
have : interior d ∈ 𝓤 α := by filter_upwards [hs] using this
simp [this])
fun _ hs => ((𝓤 α).lift' interior).sets_of_superset (mem_lift' hs) interior_subset | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformity_eq_uniformity_interior | null |
interior_mem_uniformity {s : Set (α × α)} (hs : s ∈ 𝓤 α) : interior s ∈ 𝓤 α := by
rw [uniformity_eq_uniformity_interior]; exact mem_lift' hs | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | interior_mem_uniformity | null |
mem_uniformity_isClosed {s : Set (α × α)} (h : s ∈ 𝓤 α) : ∃ t ∈ 𝓤 α, IsClosed t ∧ t ⊆ s :=
let ⟨t, ⟨ht_mem, htc⟩, hts⟩ := uniformity_hasBasis_closed.mem_iff.1 h
⟨t, ht_mem, htc, hts⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | mem_uniformity_isClosed | null |
isOpen_iff_isOpen_ball_subset {s : Set α} :
IsOpen s ↔ ∀ x ∈ s, ∃ V ∈ 𝓤 α, IsOpen V ∧ ball x V ⊆ s := by
rw [isOpen_iff_ball_subset]
constructor <;> intro h x hx
· obtain ⟨V, hV, hV'⟩ := h x hx
exact
⟨interior V, interior_mem_uniformity hV, isOpen_interior,
(ball_mono interior_subset x).trans hV'⟩
· obtain ⟨V, hV, -, hV'⟩ := h x hx
exact ⟨V, hV, hV'⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | isOpen_iff_isOpen_ball_subset | null |
Dense.biUnion_uniformity_ball {s : Set α} {U : Set (α × α)} (hs : Dense s) (hU : U ∈ 𝓤 α) :
⋃ x ∈ s, ball x U = univ := by
refine iUnion₂_eq_univ_iff.2 fun y => ?_
rcases hs.inter_nhds_nonempty (mem_nhds_right y hU) with ⟨x, hxs, hxy : (x, y) ∈ U⟩
exact ⟨x, hxs, hxy⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | Dense.biUnion_uniformity_ball | The uniform neighborhoods of all points of a dense set cover the whole space. |
DenseRange.iUnion_uniformity_ball {ι : Type*} {xs : ι → α}
(xs_dense : DenseRange xs) {U : Set (α × α)} (hU : U ∈ uniformity α) :
⋃ i, UniformSpace.ball (xs i) U = univ := by
rw [← biUnion_range (f := xs) (g := fun x ↦ UniformSpace.ball x U)]
exact Dense.biUnion_uniformity_ball xs_dense hU
/-! | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | DenseRange.iUnion_uniformity_ball | The uniform neighborhoods of all points of a dense indexed collection cover the whole space. |
uniformity_hasBasis_open : HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α ∧ IsOpen V) id :=
hasBasis_self.2 fun s hs =>
⟨interior s, interior_mem_uniformity hs, isOpen_interior, interior_subset⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformity_hasBasis_open | Open elements of `𝓤 α` form a basis of `𝓤 α`. |
Filter.HasBasis.mem_uniformity_iff {p : β → Prop} {s : β → Set (α × α)}
(h : (𝓤 α).HasBasis p s) {t : Set (α × α)} :
t ∈ 𝓤 α ↔ ∃ i, p i ∧ ∀ a b, (a, b) ∈ s i → (a, b) ∈ t :=
h.mem_iff.trans <| by simp only [Prod.forall, subset_def] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | Filter.HasBasis.mem_uniformity_iff | null |
uniformity_hasBasis_open_symmetric :
HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α ∧ IsOpen V ∧ IsSymmetricRel V) id := by
simp only [← and_assoc]
refine uniformity_hasBasis_open.restrict fun s hs => ⟨symmetrizeRel s, ?_⟩
exact
⟨⟨symmetrize_mem_uniformity hs.1, IsOpen.inter hs.2 (hs.2.preimage continuous_swap)⟩,
symmetric_symmetrizeRel s, symmetrizeRel_subset_self s⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformity_hasBasis_open_symmetric | Open elements `s : Set (α × α)` of `𝓤 α` such that `(x, y) ∈ s ↔ (y, x) ∈ s` form a basis
of `𝓤 α`. |
comp_open_symm_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
∃ t ∈ 𝓤 α, IsOpen t ∧ IsSymmetricRel t ∧ t ○ t ⊆ s := by
obtain ⟨t, ht₁, ht₂⟩ := comp_mem_uniformity_sets hs
obtain ⟨u, ⟨hu₁, hu₂, hu₃⟩, hu₄ : u ⊆ t⟩ := uniformity_hasBasis_open_symmetric.mem_iff.mp ht₁
exact ⟨u, hu₁, hu₂, hu₃, (compRel_mono hu₄ hu₄).trans ht₂⟩ | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | comp_open_symm_mem_uniformity_sets | null |
protected UniformSpace.le_def {u₁ u₂ : UniformSpace α} : u₁ ≤ u₂ ↔ 𝓤[u₁] ≤ 𝓤[u₂] := Iff.rfl | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.le_def | null |
protected UniformSpace.sInf_le {tt : Set (UniformSpace α)} {t : UniformSpace α}
(h : t ∈ tt) : sInf tt ≤ t :=
show ⨅ u ∈ tt, 𝓤[u] ≤ 𝓤[t] from iInf₂_le t h | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.sInf_le | null |
protected UniformSpace.le_sInf {tt : Set (UniformSpace α)} {t : UniformSpace α}
(h : ∀ t' ∈ tt, t ≤ t') : t ≤ sInf tt :=
show 𝓤[t] ≤ ⨅ u ∈ tt, 𝓤[u] from le_iInf₂ h | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.le_sInf | null |
iInf_uniformity {ι : Sort*} {u : ι → UniformSpace α} : 𝓤[iInf u] = ⨅ i, 𝓤[u i] :=
iInf_range | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | iInf_uniformity | null |
inf_uniformity {u v : UniformSpace α} : 𝓤[u ⊓ v] = 𝓤[u] ⊓ 𝓤[v] := rfl | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | inf_uniformity | null |
bot_uniformity : 𝓤[(⊥ : UniformSpace α)] = 𝓟 idRel := rfl | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | bot_uniformity | null |
top_uniformity : 𝓤[(⊤ : UniformSpace α)] = ⊤ := rfl | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | top_uniformity | null |
inhabitedUniformSpace : Inhabited (UniformSpace α) :=
⟨⊥⟩ | instance | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | inhabitedUniformSpace | null |
inhabitedUniformSpaceCore : Inhabited (UniformSpace.Core α) :=
⟨@UniformSpace.toCore _ default⟩ | instance | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | inhabitedUniformSpaceCore | null |
UniformSpace.comap (f : α → β) (u : UniformSpace β) : UniformSpace α where
uniformity := 𝓤[u].comap fun p : α × α => (f p.1, f p.2)
symm := by
simp only [tendsto_comap_iff]
exact tendsto_swap_uniformity.comp tendsto_comap
comp := le_trans
(by
rw [comap_lift'_eq, comap_lift'_eq2]
· exact lift'_mono' fun s _ ⟨a₁, a₂⟩ ⟨x, h₁, h₂⟩ => ⟨f x, h₁, h₂⟩
· exact monotone_id.compRel monotone_id)
(comap_mono u.comp)
toTopologicalSpace := u.toTopologicalSpace.induced f
nhds_eq_comap_uniformity x := by
simp only [nhds_induced, nhds_eq_comap_uniformity, comap_comap, Function.comp_def] | abbrev | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.comap | Given `f : α → β` and a uniformity `u` on `β`, the inverse image of `u` under `f`
is the inverse image in the filter sense of the induced function `α × α → β × β`.
See note [reducible non-instances]. |
uniformity_comap {_ : UniformSpace β} (f : α → β) :
𝓤[UniformSpace.comap f ‹_›] = comap (Prod.map f f) (𝓤 β) :=
rfl | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformity_comap | null |
ball_preimage {f : α → β} {U : Set (β × β)} {x : α} :
UniformSpace.ball x (Prod.map f f ⁻¹' U) = f ⁻¹' UniformSpace.ball (f x) U := by
ext : 1
simp only [UniformSpace.ball, mem_preimage, Prod.map_apply]
@[simp] | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | ball_preimage | null |
uniformSpace_comap_id {α : Type*} : UniformSpace.comap (id : α → α) = id := by
ext : 2
rw [uniformity_comap, Prod.map_id, comap_id] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformSpace_comap_id | null |
UniformSpace.comap_comap {α β γ} {uγ : UniformSpace γ} {f : α → β} {g : β → γ} :
UniformSpace.comap (g ∘ f) uγ = UniformSpace.comap f (UniformSpace.comap g uγ) := by
ext1
simp only [uniformity_comap, Filter.comap_comap, Prod.map_comp_map] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.comap_comap | null |
UniformSpace.comap_inf {α γ} {u₁ u₂ : UniformSpace γ} {f : α → γ} :
(u₁ ⊓ u₂).comap f = u₁.comap f ⊓ u₂.comap f :=
UniformSpace.ext Filter.comap_inf | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.comap_inf | null |
UniformSpace.comap_iInf {ι α γ} {u : ι → UniformSpace γ} {f : α → γ} :
(⨅ i, u i).comap f = ⨅ i, (u i).comap f := by
ext : 1
simp [uniformity_comap, iInf_uniformity] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.comap_iInf | null |
UniformSpace.comap_mono {α γ} {f : α → γ} :
Monotone fun u : UniformSpace γ => u.comap f := fun _ _ hu =>
Filter.comap_mono hu | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | UniformSpace.comap_mono | null |
uniformContinuous_iff {α β} {uα : UniformSpace α} {uβ : UniformSpace β} {f : α → β} :
UniformContinuous f ↔ uα ≤ uβ.comap f :=
Filter.map_le_iff_le_comap | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformContinuous_iff | null |
le_iff_uniformContinuous_id {u v : UniformSpace α} :
u ≤ v ↔ @UniformContinuous _ _ u v id := by
rw [uniformContinuous_iff, uniformSpace_comap_id, id] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | le_iff_uniformContinuous_id | null |
uniformContinuous_comap {f : α → β} [u : UniformSpace β] :
@UniformContinuous α β (UniformSpace.comap f u) u f :=
tendsto_comap | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformContinuous_comap | null |
uniformContinuous_comap' {f : γ → β} {g : α → γ} [v : UniformSpace β] [u : UniformSpace α]
(h : UniformContinuous (f ∘ g)) : @UniformContinuous α γ u (UniformSpace.comap f v) g :=
tendsto_comap_iff.2 h | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformContinuous_comap' | null |
to_nhds_mono {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂) (a : α) :
@nhds _ (@UniformSpace.toTopologicalSpace _ u₁) a ≤
@nhds _ (@UniformSpace.toTopologicalSpace _ u₂) a := by
rw [@nhds_eq_uniformity α u₁ a, @nhds_eq_uniformity α u₂ a]; exact lift'_mono h le_rfl | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | to_nhds_mono | null |
toTopologicalSpace_mono {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂) :
@UniformSpace.toTopologicalSpace _ u₁ ≤ @UniformSpace.toTopologicalSpace _ u₂ :=
le_of_nhds_le_nhds <| to_nhds_mono h | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | toTopologicalSpace_mono | null |
toTopologicalSpace_comap {f : α → β} {u : UniformSpace β} :
@UniformSpace.toTopologicalSpace _ (UniformSpace.comap f u) =
TopologicalSpace.induced f (@UniformSpace.toTopologicalSpace β u) :=
rfl | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | toTopologicalSpace_comap | null |
uniformSpace_eq_bot {u : UniformSpace α} : u = ⊥ ↔ idRel ∈ 𝓤[u] :=
le_bot_iff.symm.trans le_principal_iff | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | uniformSpace_eq_bot | null |
protected _root_.Filter.HasBasis.uniformSpace_eq_bot {ι p} {s : ι → Set (α × α)}
{u : UniformSpace α} (h : 𝓤[u].HasBasis p s) :
u = ⊥ ↔ ∃ i, p i ∧ Pairwise fun x y : α ↦ (x, y) ∉ s i := by
simp [uniformSpace_eq_bot, h.mem_iff, subset_def, Pairwise, not_imp_not] | lemma | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | _root_.Filter.HasBasis.uniformSpace_eq_bot | null |
toTopologicalSpace_bot : @UniformSpace.toTopologicalSpace α ⊥ = ⊥ := rfl | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | toTopologicalSpace_bot | null |
toTopologicalSpace_top : @UniformSpace.toTopologicalSpace α ⊤ = ⊤ := rfl | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | toTopologicalSpace_top | null |
toTopologicalSpace_iInf {ι : Sort*} {u : ι → UniformSpace α} :
(iInf u).toTopologicalSpace = ⨅ i, (u i).toTopologicalSpace :=
TopologicalSpace.ext_nhds fun a ↦ by simp only [@nhds_eq_comap_uniformity _ (iInf u), nhds_iInf,
iInf_uniformity, @nhds_eq_comap_uniformity _ (u _), Filter.comap_iInf] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | toTopologicalSpace_iInf | null |
toTopologicalSpace_sInf {s : Set (UniformSpace α)} :
(sInf s).toTopologicalSpace = ⨅ i ∈ s, @UniformSpace.toTopologicalSpace α i := by
rw [sInf_eq_iInf]
simp only [← toTopologicalSpace_iInf] | theorem | Topology | [
"Mathlib.Data.Rel",
"Mathlib.Order.Filter.SmallSets",
"Mathlib.Topology.UniformSpace.Defs",
"Mathlib.Topology.ContinuousOn"
] | Mathlib/Topology/UniformSpace/Basic.lean | toTopologicalSpace_sInf | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.