Module docstring
{"# Uniform embeddings of uniform spaces.
Extension of uniform continuous functions. ","### Uniform inducing maps ","### Uniform embeddings "}
{"# Uniform embeddings of uniform spaces.
Extension of uniform continuous functions. ","### Uniform inducing maps ","### Uniform embeddings "}
IsUniformInducing
structure
(f : α → β)
/-- A map `f : α → β` between uniform spaces is called *uniform inducing* if the uniformity filter
on `α` is the pullback of the uniformity filter on `β` under `Prod.map f f`. If `α` is a separated
space, then this implies that `f` is injective, hence it is a `IsUniformEmbedding`. -/
@[mk_iff]
structure IsUniformInducing (f : α → β) : Prop where
/-- The uniformity filter on the domain is the pullback of the uniformity filter on the codomain
under `Prod.map f f`. -/
comap_uniformity : comap (fun x : α × α => (f x.1, f x.2)) (𝓤 β) = 𝓤 α
isUniformInducing_iff_uniformSpace
theorem
{f : α → β} : IsUniformInducing f ↔ ‹UniformSpace β›.comap f = ‹UniformSpace α›
lemma isUniformInducing_iff_uniformSpace {f : α → β} :
IsUniformInducingIsUniformInducing f ↔ ‹UniformSpace β›.comap f = ‹UniformSpace α› := by
rw [isUniformInducing_iff, UniformSpace.ext_iff, Filter.ext_iff]
rfl
isUniformInducing_iff'
theorem
{f : α → β} : IsUniformInducing f ↔ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
lemma isUniformInducing_iff' {f : α → β} :
IsUniformInducingIsUniformInducing f ↔ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α := by
rw [isUniformInducing_iff, UniformContinuous, tendsto_iff_comap, le_antisymm_iff, and_comm]; rfl
Filter.HasBasis.isUniformInducing_iff
theorem
{ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'} (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
IsUniformInducing f ↔
(∀ i, p' i → ∃ j, p j ∧ ∀ x y, (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
(∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j)
protected lemma Filter.HasBasis.isUniformInducing_iff {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
(h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
IsUniformInducingIsUniformInducing f ↔
(∀ i, p' i → ∃ j, p j ∧ ∀ x y, (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
(∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j) := by
simp [isUniformInducing_iff', h.uniformContinuous_iff h', (h'.comap _).le_basis_iff h, subset_def]
IsUniformInducing.mk'
theorem
{f : α → β} (h : ∀ s, s ∈ 𝓤 α ↔ ∃ t ∈ 𝓤 β, ∀ x y : α, (f x, f y) ∈ t → (x, y) ∈ s) : IsUniformInducing f
theorem IsUniformInducing.mk' {f : α → β}
(h : ∀ s, s ∈ 𝓤 αs ∈ 𝓤 α ↔ ∃ t ∈ 𝓤 β, ∀ x y : α, (f x, f y) ∈ t → (x, y) ∈ s) : IsUniformInducing f :=
⟨by simp [eq_comm, Filter.ext_iff, subset_def, h]⟩
IsUniformInducing.id
theorem
: IsUniformInducing (@id α)
theorem IsUniformInducing.id : IsUniformInducing (@id α) :=
⟨by rw [← Prod.map_def, Prod.map_id, comap_id]⟩
IsUniformInducing.comp
theorem
{g : β → γ} (hg : IsUniformInducing g) {f : α → β} (hf : IsUniformInducing f) : IsUniformInducing (g ∘ f)
theorem IsUniformInducing.comp {g : β → γ} (hg : IsUniformInducing g) {f : α → β}
(hf : IsUniformInducing f) : IsUniformInducing (g ∘ f) :=
⟨by rw [← hf.1, ← hg.1, comap_comap]; rfl⟩
IsUniformInducing.of_comp_iff
theorem
{g : β → γ} (hg : IsUniformInducing g) {f : α → β} : IsUniformInducing (g ∘ f) ↔ IsUniformInducing f
theorem IsUniformInducing.of_comp_iff {g : β → γ} (hg : IsUniformInducing g) {f : α → β} :
IsUniformInducingIsUniformInducing (g ∘ f) ↔ IsUniformInducing f := by
refine ⟨fun h ↦ ?_, hg.comp⟩
rw [isUniformInducing_iff, ← hg.comap_uniformity, comap_comap, ← h.comap_uniformity,
Function.comp_def, Function.comp_def]
IsUniformInducing.basis_uniformity
theorem
{f : α → β} (hf : IsUniformInducing f) {ι : Sort*} {p : ι → Prop} {s : ι → Set (β × β)} (H : (𝓤 β).HasBasis p s) :
(𝓤 α).HasBasis p fun i => Prod.map f f ⁻¹' s i
theorem IsUniformInducing.basis_uniformity {f : α → β} (hf : IsUniformInducing f) {ι : Sort*}
{p : ι → Prop} {s : ι → Set (β × β)} (H : (𝓤 β).HasBasis p s) :
(𝓤 α).HasBasis p fun i => Prod.mapProd.map f f ⁻¹' s i :=
hf.1 ▸ H.comap _
IsUniformInducing.cauchy_map_iff
theorem
{f : α → β} (hf : IsUniformInducing f) {F : Filter α} : Cauchy (map f F) ↔ Cauchy F
theorem IsUniformInducing.cauchy_map_iff {f : α → β} (hf : IsUniformInducing f) {F : Filter α} :
CauchyCauchy (map f F) ↔ Cauchy F := by
simp only [Cauchy, map_neBot_iff, prod_map_map_eq, map_le_iff_le_comap, ← hf.comap_uniformity]
IsUniformInducing.of_comp
theorem
{f : α → β} {g : β → γ} (hf : UniformContinuous f) (hg : UniformContinuous g) (hgf : IsUniformInducing (g ∘ f)) :
IsUniformInducing f
theorem IsUniformInducing.of_comp {f : α → β} {g : β → γ} (hf : UniformContinuous f)
(hg : UniformContinuous g) (hgf : IsUniformInducing (g ∘ f)) : IsUniformInducing f := by
refine ⟨le_antisymm ?_ hf.le_comap⟩
rw [← hgf.1, ← Prod.map_def, ← Prod.map_def, ← Prod.map_comp_map f f g g, ← comap_comap]
exact comap_mono hg.le_comap
IsUniformInducing.uniformContinuous
theorem
{f : α → β} (hf : IsUniformInducing f) : UniformContinuous f
theorem IsUniformInducing.uniformContinuous {f : α → β} (hf : IsUniformInducing f) :
UniformContinuous f := (isUniformInducing_iff'.1 hf).1
IsUniformInducing.uniformContinuous_iff
theorem
{f : α → β} {g : β → γ} (hg : IsUniformInducing g) : UniformContinuous f ↔ UniformContinuous (g ∘ f)
theorem IsUniformInducing.uniformContinuous_iff {f : α → β} {g : β → γ} (hg : IsUniformInducing g) :
UniformContinuousUniformContinuous f ↔ UniformContinuous (g ∘ f) := by
dsimp only [UniformContinuous, Tendsto]
simp only [← hg.comap_uniformity, ← map_le_iff_le_comap, Filter.map_map, Function.comp_def]
IsUniformInducing.isUniformInducing_comp_iff
theorem
{f : α → β} {g : β → γ} (hg : IsUniformInducing g) : IsUniformInducing (g ∘ f) ↔ IsUniformInducing f
protected theorem IsUniformInducing.isUniformInducing_comp_iff {f : α → β} {g : β → γ}
(hg : IsUniformInducing g) : IsUniformInducingIsUniformInducing (g ∘ f) ↔ IsUniformInducing f := by
simp only [isUniformInducing_iff, ← hg.comap_uniformity, comap_comap, Function.comp_def]
IsUniformInducing.uniformContinuousOn_iff
theorem
{f : α → β} {g : β → γ} {S : Set α} (hg : IsUniformInducing g) :
UniformContinuousOn f S ↔ UniformContinuousOn (g ∘ f) S
theorem IsUniformInducing.uniformContinuousOn_iff {f : α → β} {g : β → γ} {S : Set α}
(hg : IsUniformInducing g) :
UniformContinuousOnUniformContinuousOn f S ↔ UniformContinuousOn (g ∘ f) S := by
dsimp only [UniformContinuousOn, Tendsto]
rw [← hg.comap_uniformity, ← map_le_iff_le_comap, Filter.map_map, comp_def, comp_def]
IsUniformInducing.isInducing
theorem
{f : α → β} (h : IsUniformInducing f) : IsInducing f
theorem IsUniformInducing.isInducing {f : α → β} (h : IsUniformInducing f) : IsInducing f := by
obtain rfl := h.comap_uniformSpace
exact .induced f
IsUniformInducing.prod
theorem
{α' : Type*} {β' : Type*} [UniformSpace α'] [UniformSpace β'] {e₁ : α → α'} {e₂ : β → β'} (h₁ : IsUniformInducing e₁)
(h₂ : IsUniformInducing e₂) : IsUniformInducing fun p : α × β => (e₁ p.1, e₂ p.2)
theorem IsUniformInducing.prod {α' : Type*} {β' : Type*} [UniformSpace α'] [UniformSpace β']
{e₁ : α → α'} {e₂ : β → β'} (h₁ : IsUniformInducing e₁) (h₂ : IsUniformInducing e₂) :
IsUniformInducing fun p : α × β => (e₁ p.1, e₂ p.2) :=
⟨by simp [Function.comp_def, uniformity_prod, ← h₁.1, ← h₂.1, comap_inf, comap_comap]⟩
IsUniformInducing.isDenseInducing
theorem
(h : IsUniformInducing f) (hd : DenseRange f) : IsDenseInducing f
lemma IsUniformInducing.isDenseInducing (h : IsUniformInducing f) (hd : DenseRange f) :
IsDenseInducing f where
toIsInducing := h.isInducing
dense := hd
SeparationQuotient.isUniformInducing_mk
theorem
: IsUniformInducing (mk : α → SeparationQuotient α)
lemma SeparationQuotient.isUniformInducing_mk :
IsUniformInducing (mk : α → SeparationQuotient α) :=
⟨comap_mk_uniformity⟩
IsUniformInducing.injective
theorem
[T0Space α] {f : α → β} (h : IsUniformInducing f) : Injective f
protected theorem IsUniformInducing.injective [T0Space α] {f : α → β} (h : IsUniformInducing f) :
Injective f :=
h.isInducing.injective
IsUniformEmbedding
structure
(f : α → β) : Prop extends IsUniformInducing f
/-- A map `f : α → β` between uniform spaces is a *uniform embedding* if it is uniform inducing and
injective. If `α` is a separated space, then the latter assumption follows from the former. -/
@[mk_iff]
structure IsUniformEmbedding (f : α → β) : Prop extends IsUniformInducing f where
/-- A uniform embedding is injective. -/
injective : Function.Injective f
IsUniformEmbedding.isUniformInducing
theorem
(hf : IsUniformEmbedding f) : IsUniformInducing f
lemma IsUniformEmbedding.isUniformInducing (hf : IsUniformEmbedding f) : IsUniformInducing f :=
hf.toIsUniformInducing
isUniformEmbedding_iff'
theorem
{f : α → β} : IsUniformEmbedding f ↔ Injective f ∧ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α
Filter.HasBasis.isUniformEmbedding_iff'
theorem
{ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'} (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
IsUniformEmbedding f ↔
Injective f ∧
(∀ i, p' i → ∃ j, p j ∧ ∀ x y, (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
(∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j)
theorem Filter.HasBasis.isUniformEmbedding_iff' {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
(h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
IsUniformEmbeddingIsUniformEmbedding f ↔ Injective f ∧
(∀ i, p' i → ∃ j, p j ∧ ∀ x y, (x, y) ∈ s j → (f x, f y) ∈ s' i) ∧
(∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j) := by
rw [isUniformEmbedding_iff, and_comm, h.isUniformInducing_iff h']
Filter.HasBasis.isUniformEmbedding_iff
theorem
{ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'} (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
IsUniformEmbedding f ↔
Injective f ∧ UniformContinuous f ∧ (∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j)
theorem Filter.HasBasis.isUniformEmbedding_iff {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
(h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
IsUniformEmbeddingIsUniformEmbedding f ↔ Injective f ∧ UniformContinuous f ∧
(∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j) := by
simp only [h.isUniformEmbedding_iff' h', h.uniformContinuous_iff h']
isUniformEmbedding_subtype_val
theorem
{p : α → Prop} : IsUniformEmbedding (Subtype.val : Subtype p → α)
theorem isUniformEmbedding_subtype_val {p : α → Prop} :
IsUniformEmbedding (Subtype.val : Subtype p → α) :=
{ comap_uniformity := rfl
injective := Subtype.val_injective }
isUniformEmbedding_set_inclusion
theorem
{s t : Set α} (hst : s ⊆ t) : IsUniformEmbedding (inclusion hst)
theorem isUniformEmbedding_set_inclusion {s t : Set α} (hst : s ⊆ t) :
IsUniformEmbedding (inclusion hst) where
comap_uniformity := by rw [uniformity_subtype, uniformity_subtype, comap_comap]; rfl
injective := inclusion_injective hst
IsUniformEmbedding.comp
theorem
{g : β → γ} (hg : IsUniformEmbedding g) {f : α → β} (hf : IsUniformEmbedding f) : IsUniformEmbedding (g ∘ f)
theorem IsUniformEmbedding.comp {g : β → γ} (hg : IsUniformEmbedding g) {f : α → β}
(hf : IsUniformEmbedding f) : IsUniformEmbedding (g ∘ f) where
toIsUniformInducing := hg.isUniformInducing.comp hf.isUniformInducing
injective := hg.injective.comp hf.injective
IsUniformEmbedding.of_comp_iff
theorem
{g : β → γ} (hg : IsUniformEmbedding g) {f : α → β} : IsUniformEmbedding (g ∘ f) ↔ IsUniformEmbedding f
theorem IsUniformEmbedding.of_comp_iff {g : β → γ} (hg : IsUniformEmbedding g) {f : α → β} :
IsUniformEmbeddingIsUniformEmbedding (g ∘ f) ↔ IsUniformEmbedding f := by
simp_rw [isUniformEmbedding_iff, hg.isUniformInducing.of_comp_iff, hg.injective.of_comp_iff f]
Equiv.isUniformEmbedding
theorem
{α β : Type*} [UniformSpace α] [UniformSpace β] (f : α ≃ β) (h₁ : UniformContinuous f)
(h₂ : UniformContinuous f.symm) : IsUniformEmbedding f
theorem Equiv.isUniformEmbedding {α β : Type*} [UniformSpace α] [UniformSpace β] (f : α ≃ β)
(h₁ : UniformContinuous f) (h₂ : UniformContinuous f.symm) : IsUniformEmbedding f :=
isUniformEmbedding_iff'.2 ⟨f.injective, h₁, by rwa [← Equiv.prodCongr_apply, ← map_equiv_symm]⟩
isUniformEmbedding_inl
theorem
: IsUniformEmbedding (Sum.inl : α → α ⊕ β)
theorem isUniformEmbedding_inl : IsUniformEmbedding (Sum.inl : α → α ⊕ β) :=
isUniformEmbedding_iff'.2 ⟨Sum.inl_injective, uniformContinuous_inl, fun s hs =>
⟨Prod.map Sum.inl Sum.inl '' s ∪ range (Prod.map Sum.inr Sum.inr),
union_mem_sup (image_mem_map hs) range_mem_map,
fun x h => by simpa [Prod.map_apply'] using h⟩⟩
isUniformEmbedding_inr
theorem
: IsUniformEmbedding (Sum.inr : β → α ⊕ β)
theorem isUniformEmbedding_inr : IsUniformEmbedding (Sum.inr : β → α ⊕ β) :=
isUniformEmbedding_iff'.2 ⟨Sum.inr_injective, uniformContinuous_inr, fun s hs =>
⟨range (Prod.map Sum.inl Sum.inl) ∪ Prod.map Sum.inr Sum.inr '' s,
union_mem_sup range_mem_map (image_mem_map hs),
fun x h => by simpa [Prod.map_apply'] using h⟩⟩
IsUniformInducing.isUniformEmbedding
theorem
[T0Space α] {f : α → β} (hf : IsUniformInducing f) : IsUniformEmbedding f
/-- If the domain of a `IsUniformInducing` map `f` is a T₀ space, then `f` is injective,
hence it is a `IsUniformEmbedding`. -/
protected theorem IsUniformInducing.isUniformEmbedding [T0Space α] {f : α → β}
(hf : IsUniformInducing f) : IsUniformEmbedding f :=
⟨hf, hf.isInducing.injective⟩
isUniformEmbedding_iff_isUniformInducing
theorem
[T0Space α] {f : α → β} : IsUniformEmbedding f ↔ IsUniformInducing f
comap_uniformity_of_spaced_out
theorem
{α} {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β) (hf : Pairwise fun x y => (f x, f y) ∉ s) :
comap (Prod.map f f) (𝓤 β) = 𝓟 idRel
/-- If a map `f : α → β` sends any two distinct points to point that are **not** related by a fixed
`s ∈ 𝓤 β`, then `f` is uniform inducing with respect to the discrete uniformity on `α`:
the preimage of `𝓤 β` under `Prod.map f f` is the principal filter generated by the diagonal in
`α × α`. -/
theorem comap_uniformity_of_spaced_out {α} {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β)
(hf : Pairwise fun x y => (f x, f y)(f x, f y) ∉ s) : comap (Prod.map f f) (𝓤 β) = 𝓟 idRel := by
refine le_antisymm ?_ (@refl_le_uniformity α (UniformSpace.comap f _))
calc
comap (Prod.map f f) (𝓤 β) ≤ comap (Prod.map f f) (𝓟 s) := comap_mono (le_principal_iff.2 hs)
_ = 𝓟 (Prod.mapProd.map f f ⁻¹' s) := comap_principal
_ ≤ 𝓟 idRel := principal_mono.2 ?_
rintro ⟨x, y⟩; simpa [not_imp_not] using @hf x y
isUniformEmbedding_of_spaced_out
theorem
{α} {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β) (hf : Pairwise fun x y => (f x, f y) ∉ s) :
@IsUniformEmbedding α β ⊥ ‹_› f
/-- If a map `f : α → β` sends any two distinct points to point that are **not** related by a fixed
`s ∈ 𝓤 β`, then `f` is a uniform embedding with respect to the discrete uniformity on `α`. -/
theorem isUniformEmbedding_of_spaced_out {α} {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β)
(hf : Pairwise fun x y => (f x, f y)(f x, f y) ∉ s) : @IsUniformEmbedding α β ⊥ ‹_› f := by
let _ : UniformSpace α := ⊥; have := discreteTopology_bot α
exact IsUniformInducing.isUniformEmbedding ⟨comap_uniformity_of_spaced_out hs hf⟩
IsUniformEmbedding.isEmbedding
theorem
{f : α → β} (h : IsUniformEmbedding f) : IsEmbedding f
protected lemma IsUniformEmbedding.isEmbedding {f : α → β} (h : IsUniformEmbedding f) :
IsEmbedding f where
toIsInducing := h.toIsUniformInducing.isInducing
injective := h.injective
IsUniformEmbedding.isDenseEmbedding
theorem
{f : α → β} (h : IsUniformEmbedding f) (hd : DenseRange f) : IsDenseEmbedding f
theorem IsUniformEmbedding.isDenseEmbedding {f : α → β} (h : IsUniformEmbedding f)
(hd : DenseRange f) : IsDenseEmbedding f :=
{ h.isEmbedding with dense := hd }
isClosedEmbedding_of_spaced_out
theorem
{α} [TopologicalSpace α] [DiscreteTopology α] [T0Space β] {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β)
(hf : Pairwise fun x y => (f x, f y) ∉ s) : IsClosedEmbedding f
theorem isClosedEmbedding_of_spaced_out {α} [TopologicalSpace α] [DiscreteTopology α]
[T0Space β] {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β)
(hf : Pairwise fun x y => (f x, f y)(f x, f y) ∉ s) : IsClosedEmbedding f := by
rcases @DiscreteTopology.eq_bot α _ _ with rfl; let _ : UniformSpace α := ⊥
exact
{ (isUniformEmbedding_of_spaced_out hs hf).isEmbedding with
isClosed_range := isClosed_range_of_spaced_out hs hf }
closure_image_mem_nhds_of_isUniformInducing
theorem
{s : Set (α × α)} {e : α → β} (b : β) (he₁ : IsUniformInducing e) (he₂ : IsDenseInducing e) (hs : s ∈ 𝓤 α) :
∃ a, closure (e '' {a' | (a, a') ∈ s}) ∈ 𝓝 b
theorem closure_image_mem_nhds_of_isUniformInducing {s : Set (α × α)} {e : α → β} (b : β)
(he₁ : IsUniformInducing e) (he₂ : IsDenseInducing e) (hs : s ∈ 𝓤 α) :
∃ a, closure (e '' { a' | (a, a') ∈ s }) ∈ 𝓝 b := by
obtain ⟨U, ⟨hU, hUo, hsymm⟩, hs⟩ :
∃ U, (U ∈ 𝓤 β ∧ IsOpen U ∧ IsSymmetricRel U) ∧ Prod.map e e ⁻¹' U ⊆ s := by
rwa [← he₁.comap_uniformity, (uniformity_hasBasis_open_symmetric.comap _).mem_iff] at hs
rcases he₂.dense.mem_nhds (UniformSpace.ball_mem_nhds b hU) with ⟨a, ha⟩
refine ⟨a, mem_of_superset ?_ (closure_mono <| image_subset _ <| UniformSpace.ball_mono hs a)⟩
have ho : IsOpen (UniformSpace.ball (e a) U) := UniformSpace.isOpen_ball (e a) hUo
refine mem_of_superset (ho.mem_nhds <| (UniformSpace.mem_ball_symmetry hsymm).2 ha) fun y hy => ?_
refine mem_closure_iff_nhds.2 fun V hV => ?_
rcases he₂.dense.mem_nhds (inter_mem hV (ho.mem_nhds hy)) with ⟨x, hxV, hxU⟩
exact ⟨e x, hxV, mem_image_of_mem e hxU⟩
isUniformEmbedding_subtypeEmb
theorem
(p : α → Prop) {e : α → β} (ue : IsUniformEmbedding e) (de : IsDenseEmbedding e) :
IsUniformEmbedding (IsDenseEmbedding.subtypeEmb p e)
theorem isUniformEmbedding_subtypeEmb (p : α → Prop) {e : α → β} (ue : IsUniformEmbedding e)
(de : IsDenseEmbedding e) : IsUniformEmbedding (IsDenseEmbedding.subtypeEmb p e) :=
{ comap_uniformity := by
simp [comap_comap, Function.comp_def, IsDenseEmbedding.subtypeEmb, uniformity_subtype,
ue.comap_uniformity.symm]
injective := (de.subtype p).injective }
IsUniformEmbedding.prod
theorem
{α' : Type*} {β' : Type*} [UniformSpace α'] [UniformSpace β'] {e₁ : α → α'} {e₂ : β → β'} (h₁ : IsUniformEmbedding e₁)
(h₂ : IsUniformEmbedding e₂) : IsUniformEmbedding fun p : α × β => (e₁ p.1, e₂ p.2)
theorem IsUniformEmbedding.prod {α' : Type*} {β' : Type*} [UniformSpace α'] [UniformSpace β']
{e₁ : α → α'} {e₂ : β → β'} (h₁ : IsUniformEmbedding e₁) (h₂ : IsUniformEmbedding e₂) :
IsUniformEmbedding fun p : α × β => (e₁ p.1, e₂ p.2) where
toIsUniformInducing := h₁.isUniformInducing.prod h₂.isUniformInducing
injective := h₁.injective.prodMap h₂.injective
isComplete_image_iff
theorem
{m : α → β} {s : Set α} (hm : IsUniformInducing m) : IsComplete (m '' s) ↔ IsComplete s
/-- A set is complete iff its image under a uniform inducing map is complete. -/
theorem isComplete_image_iff {m : α → β} {s : Set α} (hm : IsUniformInducing m) :
IsCompleteIsComplete (m '' s) ↔ IsComplete s := by
have fact1 : SurjOn (map m) (Iic <| 𝓟 s) (Iic <| 𝓟 <| m '' s) := surjOn_image .. |>.filter_map_Iic
have fact2 : MapsTo (map m) (Iic <| 𝓟 s) (Iic <| 𝓟 <| m '' s) := mapsTo_image .. |>.filter_map_Iic
simp_rw [IsComplete, imp.swap (a := Cauchy _), ← mem_Iic (b := 𝓟 _), fact1.forall fact2,
hm.cauchy_map_iff, exists_mem_image, map_le_iff_le_comap, hm.isInducing.nhds_eq_comap]
IsUniformInducing.isComplete_iff
theorem
{f : α → β} {s : Set α} (hf : IsUniformInducing f) : IsComplete (f '' s) ↔ IsComplete s
/-- If `f : X → Y` is an `IsUniformInducing` map, the image `f '' s` of a set `s` is complete
if and only if `s` is complete. -/
theorem IsUniformInducing.isComplete_iff {f : α → β} {s : Set α} (hf : IsUniformInducing f) :
IsCompleteIsComplete (f '' s) ↔ IsComplete s := isComplete_image_iff hf
IsUniformEmbedding.isComplete_iff
theorem
{f : α → β} {s : Set α} (hf : IsUniformEmbedding f) : IsComplete (f '' s) ↔ IsComplete s
/-- If `f : X → Y` is an `IsUniformEmbedding`, the image `f '' s` of a set `s` is complete
if and only if `s` is complete. -/
theorem IsUniformEmbedding.isComplete_iff {f : α → β} {s : Set α} (hf : IsUniformEmbedding f) :
IsCompleteIsComplete (f '' s) ↔ IsComplete s := hf.isUniformInducing.isComplete_iff
Subtype.isComplete_iff
theorem
{p : α → Prop} {s : Set { x // p x }} : IsComplete s ↔ IsComplete ((↑) '' s : Set α)
/-- Sets of a subtype are complete iff their image under the coercion is complete. -/
theorem Subtype.isComplete_iff {p : α → Prop} {s : Set { x // p x }} :
IsCompleteIsComplete s ↔ IsComplete ((↑) '' s : Set α) :=
isUniformEmbedding_subtype_val.isComplete_iff.symm
completeSpace_iff_isComplete_range
theorem
{f : α → β} (hf : IsUniformInducing f) : CompleteSpace α ↔ IsComplete (range f)
theorem completeSpace_iff_isComplete_range {f : α → β} (hf : IsUniformInducing f) :
CompleteSpaceCompleteSpace α ↔ IsComplete (range f) := by
rw [completeSpace_iff_isComplete_univ, ← isComplete_image_iff hf, image_univ]
IsUniformInducing.isComplete_range
theorem
[CompleteSpace α] (hf : IsUniformInducing f) : IsComplete (range f)
lemma IsUniformInducing.isComplete_range [CompleteSpace α] (hf : IsUniformInducing f) :
IsComplete (range f) :=
(completeSpace_iff_isComplete_range hf).1 ‹_›
IsUniformInducing.completeSpace_congr
theorem
{f : α → β} (hf : IsUniformInducing f) (hsurj : f.Surjective) : CompleteSpace α ↔ CompleteSpace β
/-- If `f` is a surjective uniform inducing map,
then its domain is a complete space iff its codomain is a complete space.
See also `_root_.completeSpace_congr` for a version that assumes `f` to be an equivalence. -/
theorem IsUniformInducing.completeSpace_congr {f : α → β} (hf : IsUniformInducing f)
(hsurj : f.Surjective) : CompleteSpaceCompleteSpace α ↔ CompleteSpace β := by
rw [completeSpace_iff_isComplete_range hf, hsurj.range_eq, completeSpace_iff_isComplete_univ]
SeparationQuotient.completeSpace_iff
theorem
: CompleteSpace (SeparationQuotient α) ↔ CompleteSpace α
SeparationQuotient.instCompleteSpace
instance
[CompleteSpace α] : CompleteSpace (SeparationQuotient α)
instance SeparationQuotient.instCompleteSpace [CompleteSpace α] :
CompleteSpace (SeparationQuotient α) :=
completeSpace_iff.2 ‹_›
completeSpace_congr
theorem
{e : α ≃ β} (he : IsUniformEmbedding e) : CompleteSpace α ↔ CompleteSpace β
/-- See also `IsUniformInducing.completeSpace_congr`
for a version that works for non-injective maps. -/
theorem completeSpace_congr {e : α ≃ β} (he : IsUniformEmbedding e) :
CompleteSpaceCompleteSpace α ↔ CompleteSpace β :=
he.completeSpace_congr e.surjective
completeSpace_coe_iff_isComplete
theorem
{s : Set α} : CompleteSpace s ↔ IsComplete s
IsClosed.completeSpace_coe
theorem
[CompleteSpace α] {s : Set α} (hs : IsClosed s) : CompleteSpace s
theorem IsClosed.completeSpace_coe [CompleteSpace α] {s : Set α} (hs : IsClosed s) :
CompleteSpace s :=
hs.isComplete.completeSpace_coe
completeSpace_ulift_iff
theorem
: CompleteSpace (ULift α) ↔ CompleteSpace α
ULift.instCompleteSpace
instance
[CompleteSpace α] : CompleteSpace (ULift α)
/-- The lift of a complete space to another universe is still complete. -/
instance ULift.instCompleteSpace [CompleteSpace α] : CompleteSpace (ULift α) :=
completeSpace_ulift_iff.2 ‹_›
completeSpace_extension
theorem
{m : β → α} (hm : IsUniformInducing m) (dense : DenseRange m) (h : ∀ f : Filter β, Cauchy f → ∃ x : α, map m f ≤ 𝓝 x) :
CompleteSpace α
theorem completeSpace_extension {m : β → α} (hm : IsUniformInducing m) (dense : DenseRange m)
(h : ∀ f : Filter β, Cauchy f → ∃ x : α, map m f ≤ 𝓝 x) : CompleteSpace α :=
⟨fun {f : Filter α} (hf : Cauchy f) =>
let p : Set (α × α) → Set α → Set α := fun s t => { y : α | ∃ x : α, x ∈ t ∧ (x, y) ∈ s }
let g := (𝓤 α).lift fun s => f.lift' (p s)
have mp₀ : Monotone p := fun _ _ h _ _ ⟨x, xs, xa⟩ => ⟨x, xs, h xa⟩
have mp₁ : ∀ {s}, Monotone (p s) := fun h _ ⟨y, ya, yxs⟩ => ⟨y, h ya, yxs⟩
have : f ≤ g := le_iInf₂ fun _ hs => le_iInf₂ fun _ ht =>
le_principal_iff.mpr <| mem_of_superset ht fun x hx => ⟨x, hx, refl_mem_uniformity hs⟩
have : NeBot g := hf.left.mono this
have : NeBot (comap m g) :=
comap_neBot fun _ ht =>
let ⟨t', ht', ht_mem⟩ := (mem_lift_sets <| monotone_lift' monotone_const mp₀).mp ht
let ⟨_, ht'', ht'_sub⟩ := (mem_lift'_sets mp₁).mp ht_mem
let ⟨x, hx⟩ := hf.left.nonempty_of_mem ht''
have h₀ : NeBot (𝓝[range m] x) := dense.nhdsWithin_neBot x
have h₁ : { y | (x, y) ∈ t' } ∈ 𝓝[range m] x :=
@mem_inf_of_left α (𝓝 x) (𝓟 (range m)) _ <| mem_nhds_left x ht'
have h₂ : range m ∈ 𝓝[range m] x :=
@mem_inf_of_right α (𝓝 x) (𝓟 (range m)) _ <| Subset.refl _
have : { y | (x, y) ∈ t' } ∩ range m ∈ 𝓝[range m] x := @inter_mem α (𝓝[range m] x) _ _ h₁ h₂
let ⟨_, xyt', b, b_eq⟩ := h₀.nonempty_of_mem this
⟨b, b_eq.symm ▸ ht'_sub ⟨x, hx, xyt'⟩⟩
have : Cauchy g :=
⟨‹NeBot g›, fun _ hs =>
let ⟨s₁, hs₁, comp_s₁⟩ := comp_mem_uniformity_sets hs
let ⟨s₂, hs₂, comp_s₂⟩ := comp_mem_uniformity_sets hs₁
let ⟨t, ht, (prod_t : t ×ˢ t ⊆ s₂)⟩ := mem_prod_same_iff.mp (hf.right hs₂)
have hg₁ : p (preimage Prod.swap s₁) t ∈ g :=
mem_lift (symm_le_uniformity hs₁) <| @mem_lift' α α f _ t ht
have hg₂ : p s₂ t ∈ g := mem_lift hs₂ <| @mem_lift' α α f _ t ht
have hg : p (Prod.swap ⁻¹' s₁) t ×ˢ p s₂ t ∈ g ×ˢ g := @prod_mem_prod α α _ _ g g hg₁ hg₂
(g ×ˢ g).sets_of_superset hg fun ⟨_, _⟩ ⟨⟨c₁, c₁t, hc₁⟩, ⟨c₂, c₂t, hc₂⟩⟩ =>
have : (c₁, c₂) ∈ t ×ˢ t := ⟨c₁t, c₂t⟩
comp_s₁ <| prodMk_mem_compRel hc₁ <| comp_s₂ <| prodMk_mem_compRel (prod_t this) hc₂⟩
have : Cauchy (Filter.comap m g) := ‹Cauchy g›.comap' (le_of_eq hm.comap_uniformity) ‹_›
let ⟨x, (hx : map m (Filter.comap m g) ≤ 𝓝 x)⟩ := h _ this
have : ClusterPt x (map m (Filter.comap m g)) :=
(le_nhds_iff_adhp_of_cauchy (this.map hm.uniformContinuous)).mp hx
have : ClusterPt x g := this.mono map_comap_le
⟨x,
calc
f ≤ g := by assumption
_ ≤ 𝓝 x := le_nhds_of_cauchy_adhp ‹Cauchy g› this
⟩⟩
totallyBounded_image_iff
theorem
{f : α → β} {s : Set α} (hf : IsUniformInducing f) : TotallyBounded (f '' s) ↔ TotallyBounded s
lemma totallyBounded_image_iff {f : α → β} {s : Set α} (hf : IsUniformInducing f) :
TotallyBoundedTotallyBounded (f '' s) ↔ TotallyBounded s := by
refine ⟨fun hs ↦ ?_, fun h ↦ h.image hf.uniformContinuous⟩
simp_rw [(hf.basis_uniformity (basis_sets _)).totallyBounded_iff]
intro t ht
rcases exists_subset_image_finite_and.1 (hs.exists_subset ht) with ⟨u, -, hfin, h⟩
use u, hfin
rwa [biUnion_image, image_subset_iff, preimage_iUnion₂] at h
totallyBounded_preimage
theorem
{f : α → β} {s : Set β} (hf : IsUniformInducing f) (hs : TotallyBounded s) : TotallyBounded (f ⁻¹' s)
theorem totallyBounded_preimage {f : α → β} {s : Set β} (hf : IsUniformInducing f)
(hs : TotallyBounded s) : TotallyBounded (f ⁻¹' s) :=
(totallyBounded_image_iff hf).1 <| hs.subset <| image_preimage_subset ..
CompleteSpace.sum
instance
[CompleteSpace α] [CompleteSpace β] : CompleteSpace (α ⊕ β)
instance CompleteSpace.sum [CompleteSpace α] [CompleteSpace β] : CompleteSpace (α ⊕ β) := by
rw [completeSpace_iff_isComplete_univ, ← range_inl_union_range_inr]
exact isUniformEmbedding_inl.isUniformInducing.isComplete_range.union
isUniformEmbedding_inr.isUniformInducing.isComplete_range
isUniformEmbedding_comap
theorem
{α : Type*} {β : Type*} {f : α → β} [u : UniformSpace β] (hf : Function.Injective f) :
@IsUniformEmbedding α β (UniformSpace.comap f u) u f
theorem isUniformEmbedding_comap {α : Type*} {β : Type*} {f : α → β} [u : UniformSpace β]
(hf : Function.Injective f) : @IsUniformEmbedding α β (UniformSpace.comap f u) u f :=
@IsUniformEmbedding.mk _ _ (UniformSpace.comap f u) _ _
(@IsUniformInducing.mk _ _ (UniformSpace.comap f u) _ _ rfl) hf
Topology.IsEmbedding.comapUniformSpace
definition
{α β} [TopologicalSpace α] [u : UniformSpace β] (f : α → β) (h : IsEmbedding f) : UniformSpace α
/-- Pull back a uniform space structure by an embedding, adjusting the new uniform structure to
make sure that its topology is defeq to the original one. -/
def Topology.IsEmbedding.comapUniformSpace {α β} [TopologicalSpace α] [u : UniformSpace β]
(f : α → β) (h : IsEmbedding f) : UniformSpace α :=
(u.comap f).replaceTopology h.eq_induced
Embedding.to_isUniformEmbedding
theorem
{α β} [TopologicalSpace α] [u : UniformSpace β] (f : α → β) (h : IsEmbedding f) :
@IsUniformEmbedding α β (h.comapUniformSpace f) u f
theorem Embedding.to_isUniformEmbedding {α β} [TopologicalSpace α] [u : UniformSpace β] (f : α → β)
(h : IsEmbedding f) : @IsUniformEmbedding α β (h.comapUniformSpace f) u f :=
let _ := h.comapUniformSpace f
{ comap_uniformity := rfl
injective := h.injective }
uniformly_extend_exists
theorem
[CompleteSpace γ] (a : α) : ∃ c, Tendsto f (comap e (𝓝 a)) (𝓝 c)
theorem uniformly_extend_exists [CompleteSpace γ] (a : α) : ∃ c, Tendsto f (comap e (𝓝 a)) (𝓝 c) :=
let de := h_e.isDenseInducing h_dense
have : Cauchy (𝓝 a) := cauchy_nhds
have : Cauchy (comap e (𝓝 a)) :=
this.comap' (le_of_eq h_e.comap_uniformity) (de.comap_nhds_neBot _)
have : Cauchy (map f (comap e (𝓝 a))) := this.map h_f
CompleteSpace.complete this
uniform_extend_subtype
theorem
[CompleteSpace γ] {p : α → Prop} {e : α → β} {f : α → γ} {b : β} {s : Set α}
(hf : UniformContinuous fun x : Subtype p => f x.val) (he : IsUniformEmbedding e)
(hd : ∀ x : β, x ∈ closure (range e)) (hb : closure (e '' s) ∈ 𝓝 b) (hs : IsClosed s) (hp : ∀ x ∈ s, p x) :
∃ c, Tendsto f (comap e (𝓝 b)) (𝓝 c)
theorem uniform_extend_subtype [CompleteSpace γ] {p : α → Prop} {e : α → β} {f : α → γ} {b : β}
{s : Set α} (hf : UniformContinuous fun x : Subtype p => f x.val) (he : IsUniformEmbedding e)
(hd : ∀ x : β, x ∈ closure (range e)) (hb : closureclosure (e '' s) ∈ 𝓝 b) (hs : IsClosed s)
(hp : ∀ x ∈ s, p x) : ∃ c, Tendsto f (comap e (𝓝 b)) (𝓝 c) := by
have de : IsDenseEmbedding e := he.isDenseEmbedding hd
have de' : IsDenseEmbedding (IsDenseEmbedding.subtypeEmb p e) := de.subtype p
have ue' : IsUniformEmbedding (IsDenseEmbedding.subtypeEmb p e) :=
isUniformEmbedding_subtypeEmb _ he de
have : b ∈ closure (e '' { x | p x }) :=
(closure_mono <| monotone_image <| hp) (mem_of_mem_nhds hb)
let ⟨c, hc⟩ := uniformly_extend_exists ue'.isUniformInducing de'.dense hf ⟨b, this⟩
replace hc : Tendsto (f ∘ Subtype.val (p := p)) (((𝓝 b).comap e).comap Subtype.val) (𝓝 c) := by
simpa only [nhds_subtype_eq_comap, comap_comap, IsDenseEmbedding.subtypeEmb_coe] using hc
refine ⟨c, (tendsto_comap'_iff ?_).1 hc⟩
rw [Subtype.range_coe_subtype]
exact ⟨_, hb, by rwa [← de.isInducing.closure_eq_preimage_closure_image, hs.closure_eq]⟩
uniformly_extend_spec
theorem
[CompleteSpace γ] (a : α) : Tendsto f (comap e (𝓝 a)) (𝓝 (ψ a))
theorem uniformly_extend_spec [CompleteSpace γ] (a : α) : Tendsto f (comap e (𝓝 a)) (𝓝 (ψ a)) := by
simpa only [IsDenseInducing.extend] using
tendsto_nhds_limUnder (uniformly_extend_exists h_e ‹_› h_f _)
uniformContinuous_uniformly_extend
theorem
[CompleteSpace γ] : UniformContinuous ψ
theorem uniformContinuous_uniformly_extend [CompleteSpace γ] : UniformContinuous ψ := fun d hd =>
let ⟨s, hs, hs_comp⟩ := comp3_mem_uniformity hd
have h_pnt : ∀ {a m}, m ∈ 𝓝 a → ∃ c ∈ f '' (e ⁻¹' m), (c, ψ a) ∈ s ∧ (ψ a, c) ∈ s :=
fun {a m} hm =>
have nb : NeBot (map f (comap e (𝓝 a))) :=
((h_e.isDenseInducing h_dense).comap_nhds_neBot _).map _
have :
f '' (e ⁻¹' m)f '' (e ⁻¹' m) ∩ ({ c | (c, ψ a) ∈ s } ∩ { c | (ψ a, c) ∈ s })f '' (e ⁻¹' m) ∩ ({ c | (c, ψ a) ∈ s } ∩ { c | (ψ a, c) ∈ s }) ∈ map f (comap e (𝓝 a)) :=
inter_mem (image_mem_map <| preimage_mem_comap <| hm)
(uniformly_extend_spec h_e h_dense h_f _
(inter_mem (mem_nhds_right _ hs) (mem_nhds_left _ hs)))
nb.nonempty_of_mem this
have : (Prod.map f f) ⁻¹' s(Prod.map f f) ⁻¹' s ∈ 𝓤 β := h_f hs
have : (Prod.map f f) ⁻¹' s(Prod.map f f) ⁻¹' s ∈ comap (Prod.map e e) (𝓤 α) := by
rwa [← h_e.comap_uniformity] at this
let ⟨t, ht, ts⟩ := this
show (Prod.map ψ ψ) ⁻¹' d(Prod.map ψ ψ) ⁻¹' d ∈ 𝓤 α from
mem_of_superset (interior_mem_uniformity ht) fun ⟨x₁, x₂⟩ hx_t => by
have : interiorinterior t ∈ 𝓝 (x₁, x₂) := isOpen_interior.mem_nhds hx_t
let ⟨m₁, hm₁, m₂, hm₂, (hm : m₁ ×ˢ m₂ ⊆ interior t)⟩ := mem_nhds_prod_iff.mp this
obtain ⟨_, ⟨a, ha₁, rfl⟩, _, ha₂⟩ := h_pnt hm₁
obtain ⟨_, ⟨b, hb₁, rfl⟩, hb₂, _⟩ := h_pnt hm₂
have : Prod.mapProd.map f f (a, b) ∈ s :=
ts <| mem_preimage.2 <| interior_subset (@hm (e a, e b) ⟨ha₁, hb₁⟩)
exact hs_comp ⟨f a, ha₂, ⟨f b, this, hb₂⟩⟩
uniformly_extend_of_ind
theorem
(b : β) : ψ (e b) = f b
theorem uniformly_extend_of_ind (b : β) : ψ (e b) = f b :=
IsDenseInducing.extend_eq_at _ h_f.continuous.continuousAt
uniformly_extend_unique
theorem
{g : α → γ} (hg : ∀ b, g (e b) = f b) (hc : Continuous g) : ψ = g
theorem uniformly_extend_unique {g : α → γ} (hg : ∀ b, g (e b) = f b) (hc : Continuous g) : ψ = g :=
IsDenseInducing.extend_unique _ hg hc
isUniformInducing_val
theorem
(s : Set α) : IsUniformInducing (@Subtype.val α s)
theorem isUniformInducing_val (s : Set α) :
IsUniformInducing (@Subtype.val α s) := ⟨uniformity_setCoe⟩
Dense.extend_exists
theorem
[CompleteSpace β] (hs : Dense s) (hf : UniformContinuous f) (a : α) : ∃ b, Tendsto f (comap (↑) (𝓝 a)) (𝓝 b)
theorem extend_exists [CompleteSpace β] (hs : Dense s) (hf : UniformContinuous f) (a : α) :
∃ b, Tendsto f (comap (↑) (𝓝 a)) (𝓝 b) :=
uniformly_extend_exists (isUniformInducing_val s) hs.denseRange_val hf a
Dense.extend_spec
theorem
[CompleteSpace β] (hs : Dense s) (hf : UniformContinuous f) (a : α) : Tendsto f (comap (↑) (𝓝 a)) (𝓝 (hs.extend f a))
theorem extend_spec [CompleteSpace β] (hs : Dense s) (hf : UniformContinuous f) (a : α) :
Tendsto f (comap (↑) (𝓝 a)) (𝓝 (hs.extend f a)) :=
uniformly_extend_spec (isUniformInducing_val s) hs.denseRange_val hf a
Dense.uniformContinuous_extend
theorem
[CompleteSpace β] (hs : Dense s) (hf : UniformContinuous f) : UniformContinuous (hs.extend f)
theorem uniformContinuous_extend [CompleteSpace β] (hs : Dense s) (hf : UniformContinuous f) :
UniformContinuous (hs.extend f) :=
uniformContinuous_uniformly_extend (isUniformInducing_val s) hs.denseRange_val hf
Dense.extend_of_ind
theorem
(hs : Dense s) (hf : UniformContinuous f) (x : s) : hs.extend f x = f x
theorem extend_of_ind (hs : Dense s) (hf : UniformContinuous f) (x : s) :
hs.extend f x = f x :=
IsDenseInducing.extend_eq_at _ hf.continuous.continuousAt