File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

full_name: UniformInducing.comap_uniformity
code: /-- 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 `UniformEmbedding`. -/
@[mk_iff]
structure UniformInducing (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)) (𝓤 β) = 𝓤 α
goal: Filter.comap (fun x => (f x.1, f x.2)) (𝓤 β) = 𝓤 α

full_name: uniformInducing_iff
code: /-- 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 `UniformEmbedding`. -/
@[mk_iff]
structure UniformInducing (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)) (𝓤 β) = 𝓤 α
goal: UniformInducing f ↔ Filter.comap (fun x => (f x.1, f x.2)) (𝓤 β) = 𝓤 α

full_name: UniformInducing
code: /-- 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 `UniformEmbedding`. -/
@[mk_iff]
structure UniformInducing (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)) (𝓤 β) = 𝓤 α
goal: Prop

full_name: uniformInducing_iff_uniformSpace
code: lemma uniformInducing_iff_uniformSpace {f : α → β} :
    UniformInducing f ↔ ‹UniformSpace β›.comap f = ‹UniformSpace α› 
goal: UniformInducing f ↔ UniformSpace.comap f inst✝ = inst✝¹

full_name: uniformInducing_iff'
code: lemma uniformInducing_iff' {f : α → β} :
    UniformInducing f ↔ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α 
goal: UniformInducing f ↔ UniformContinuous f ∧ Filter.comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α

full_name: Filter.HasBasis.uniformInducing_iff
code: protected lemma Filter.HasBasis.uniformInducing_iff {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
    (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
    UniformInducing 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) 
goal: UniformInducing 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

full_name: UniformInducing.mk'
code: theorem UniformInducing.mk' {f : α → β}
    (h : ∀ s, s ∈ 𝓤 α ↔ ∃ t ∈ 𝓤 β, ∀ x y : α, (f x, f y) ∈ t → (x, y) ∈ s) : UniformInducing f 
goal: UniformInducing f

full_name: uniformInducing_id
code: theorem uniformInducing_id : UniformInducing (@id α) 
goal: UniformInducing id

full_name: UniformInducing.comp
code: theorem UniformInducing.comp {g : β → γ} (hg : UniformInducing g) {f : α → β}
    (hf : UniformInducing f) : UniformInducing (g ∘ f) 
goal: UniformInducing (g ∘ f)

full_name: UniformInducing.of_comp_iff
code: theorem UniformInducing.of_comp_iff {g : β → γ} (hg : UniformInducing g) {f : α → β} :
    UniformInducing (g ∘ f) ↔ UniformInducing f 
goal: UniformInducing (g ∘ f) ↔ UniformInducing f

full_name: UniformInducing.basis_uniformity
code: theorem UniformInducing.basis_uniformity {f : α → β} (hf : UniformInducing f) {ι : Sort*}
    {p : ι → Prop} {s : ι → Set (β × β)} (H : (𝓤 β).HasBasis p s) :
    (𝓤 α).HasBasis p fun i => Prod.map f f ⁻¹' s i 
goal: (𝓤 α).HasBasis p fun i => Prod.map f f ⁻¹' s i

full_name: UniformInducing.cauchy_map_iff
code: theorem UniformInducing.cauchy_map_iff {f : α → β} (hf : UniformInducing f) {F : Filter α} :
    Cauchy (map f F) ↔ Cauchy F 
goal: Cauchy (Filter.map f F) ↔ Cauchy F

full_name: uniformInducing_of_compose
code: theorem uniformInducing_of_compose {f : α → β} {g : β → γ} (hf : UniformContinuous f)
    (hg : UniformContinuous g) (hgf : UniformInducing (g ∘ f)) : UniformInducing f 
goal: UniformInducing f

full_name: UniformInducing.uniformContinuous
code: theorem UniformInducing.uniformContinuous {f : α → β} (hf : UniformInducing f) :
    UniformContinuous f 
goal: UniformContinuous f

full_name: UniformInducing.uniformContinuous_iff
code: theorem UniformInducing.uniformContinuous_iff {f : α → β} {g : β → γ} (hg : UniformInducing g) :
    UniformContinuous f ↔ UniformContinuous (g ∘ f) 
goal: UniformContinuous f ↔ UniformContinuous (g ∘ f)

full_name: UniformInducing.uniformInducing_comp_iff
code: protected theorem UniformInducing.uniformInducing_comp_iff {f : α → β} {g : β → γ}
    (hg : UniformInducing g) : UniformInducing (g ∘ f) ↔ UniformInducing f 
goal: UniformInducing (g ∘ f) ↔ UniformInducing f

full_name: UniformInducing.uniformContinuousOn_iff
code: theorem UniformInducing.uniformContinuousOn_iff {f : α → β} {g : β → γ} {S : Set α}
    (hg : UniformInducing g) :
    UniformContinuousOn f S ↔ UniformContinuousOn (g ∘ f) S 
goal: UniformContinuousOn f S ↔ UniformContinuousOn (g ∘ f) S

full_name: UniformInducing.inducing
code: theorem UniformInducing.inducing {f : α → β} (h : UniformInducing f) : Inducing f 
goal: Inducing f

full_name: UniformInducing.prod
code: theorem UniformInducing.prod {α' : Type*} {β' : Type*} [UniformSpace α'] [UniformSpace β']
    {e₁ : α → α'} {e₂ : β → β'} (h₁ : UniformInducing e₁) (h₂ : UniformInducing e₂) :
    UniformInducing fun p : α × β => (e₁ p.1, e₂ p.2) 
goal: UniformInducing fun p => (e₁ p.1, e₂ p.2)

full_name: UniformInducing.denseInducing
code: theorem UniformInducing.denseInducing {f : α → β} (h : UniformInducing f) (hd : DenseRange f) :
    DenseInducing f 
goal: DenseInducing f

full_name: SeparationQuotient.uniformInducing_mk
code: theorem SeparationQuotient.uniformInducing_mk : UniformInducing (mk : α → SeparationQuotient α) 
goal: UniformInducing SeparationQuotient.mk

full_name: UniformInducing.injective
code: protected theorem UniformInducing.injective [T0Space α] {f : α → β} (h : UniformInducing f) :
    Injective f 
goal: Function.Injective f

full_name: UniformEmbedding.inj
code: /-- 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 UniformEmbedding (f : α → β) extends UniformInducing f : Prop where
  /-- A uniform embedding is injective. -/
  inj : Function.Injective f
goal: Function.Injective f

full_name: uniformEmbedding_iff
code: /-- 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 UniformEmbedding (f : α → β) extends UniformInducing f : Prop where
  /-- A uniform embedding is injective. -/
  inj : Function.Injective f
goal: UniformEmbedding f ↔ UniformInducing f ∧ Function.Injective f

full_name: UniformEmbedding
code: /-- 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 UniformEmbedding (f : α → β) extends UniformInducing f : Prop where
  /-- A uniform embedding is injective. -/
  inj : Function.Injective f
goal: Prop

full_name: uniformEmbedding_iff'
code: theorem uniformEmbedding_iff' {f : α → β} :
    UniformEmbedding f ↔ Injective f ∧ UniformContinuous f ∧ comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α 
goal: UniformEmbedding f ↔ Function.Injective f ∧ UniformContinuous f ∧ Filter.comap (Prod.map f f) (𝓤 β) ≤ 𝓤 α

full_name: Filter.HasBasis.uniformEmbedding_iff'
code: theorem Filter.HasBasis.uniformEmbedding_iff' {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
    (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
    UniformEmbedding 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) 
goal: UniformEmbedding f ↔
  Function.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

full_name: Filter.HasBasis.uniformEmbedding_iff
code: theorem Filter.HasBasis.uniformEmbedding_iff {ι ι'} {p : ι → Prop} {p' : ι' → Prop} {s s'}
    (h : (𝓤 α).HasBasis p s) (h' : (𝓤 β).HasBasis p' s') {f : α → β} :
    UniformEmbedding f ↔ Injective f ∧ UniformContinuous f ∧
      (∀ j, p j → ∃ i, p' i ∧ ∀ x y, (f x, f y) ∈ s' i → (x, y) ∈ s j) 
goal: UniformEmbedding f ↔
  Function.Injective f ∧
    UniformContinuous f ∧ ∀ (j : ι), p j → ∃ i, p' i ∧ ∀ (x y : α), (f x, f y) ∈ s' i → (x, y) ∈ s j

full_name: uniformEmbedding_subtype_val
code: theorem uniformEmbedding_subtype_val {p : α → Prop} :
    UniformEmbedding (Subtype.val : Subtype p → α) 
goal: UniformEmbedding Subtype.val

full_name: uniformEmbedding_set_inclusion
code: theorem uniformEmbedding_set_inclusion {s t : Set α} (hst : s ⊆ t) :
    UniformEmbedding (inclusion hst) 
goal: UniformEmbedding (Set.inclusion hst)

full_name: UniformEmbedding.comp
code: theorem UniformEmbedding.comp {g : β → γ} (hg : UniformEmbedding g) {f : α → β}
    (hf : UniformEmbedding f) : UniformEmbedding (g ∘ f) 
goal: UniformEmbedding (g ∘ f)

full_name: UniformEmbedding.of_comp_iff
code: theorem UniformEmbedding.of_comp_iff {g : β → γ} (hg : UniformEmbedding g) {f : α → β} :
    UniformEmbedding (g ∘ f) ↔ UniformEmbedding f 
goal: UniformEmbedding (g ∘ f) ↔ UniformEmbedding f

full_name: Equiv.uniformEmbedding
code: theorem Equiv.uniformEmbedding {α β : Type*} [UniformSpace α] [UniformSpace β] (f : α ≃ β)
    (h₁ : UniformContinuous f) (h₂ : UniformContinuous f.symm) : UniformEmbedding f 
goal: UniformEmbedding ⇑f

full_name: uniformEmbedding_inl
code: theorem uniformEmbedding_inl : UniformEmbedding (Sum.inl : α → α ⊕ β) 
goal: UniformEmbedding Sum.inl

full_name: uniformEmbedding_inr
code: theorem uniformEmbedding_inr : UniformEmbedding (Sum.inr : β → α ⊕ β) 
goal: UniformEmbedding Sum.inr

full_name: UniformInducing.uniformEmbedding
code: /-- If the domain of a `UniformInducing` map `f` is a T₀ space, then `f` is injective,
hence it is a `UniformEmbedding`. -/
protected theorem UniformInducing.uniformEmbedding [T0Space α] {f : α → β}
    (hf : UniformInducing f) : UniformEmbedding f 
goal: UniformEmbedding f

full_name: uniformEmbedding_iff_uniformInducing
code: theorem uniformEmbedding_iff_uniformInducing [T0Space α] {f : α → β} :
    UniformEmbedding f ↔ UniformInducing f 
goal: UniformEmbedding f ↔ UniformInducing f

full_name: comap_uniformity_of_spaced_out
code: /-- 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) ∉ s) : comap (Prod.map f f) (𝓤 β) = 𝓟 idRel 
goal: Filter.comap (Prod.map f f) (𝓤 β) = 𝓟 idRel

full_name: uniformEmbedding_of_spaced_out
code: /-- 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 uniformEmbedding_of_spaced_out {α} {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β)
    (hf : Pairwise fun x y => (f x, f y) ∉ s) : @UniformEmbedding α β ⊥ ‹_› f 
goal: UniformEmbedding f

full_name: UniformEmbedding.embedding
code: protected theorem UniformEmbedding.embedding {f : α → β} (h : UniformEmbedding f) : Embedding f 
goal: Embedding f

full_name: UniformEmbedding.denseEmbedding
code: theorem UniformEmbedding.denseEmbedding {f : α → β} (h : UniformEmbedding f) (hd : DenseRange f) :
    DenseEmbedding f 
goal: DenseEmbedding f

full_name: closedEmbedding_of_spaced_out
code: theorem closedEmbedding_of_spaced_out {α} [TopologicalSpace α] [DiscreteTopology α]
    [T0Space β] {f : α → β} {s : Set (β × β)} (hs : s ∈ 𝓤 β)
    (hf : Pairwise fun x y => (f x, f y) ∉ s) : ClosedEmbedding f 
goal: ClosedEmbedding f

full_name: closure_image_mem_nhds_of_uniformInducing
code: theorem closure_image_mem_nhds_of_uniformInducing {s : Set (α × α)} {e : α → β} (b : β)
    (he₁ : UniformInducing e) (he₂ : DenseInducing e) (hs : s ∈ 𝓤 α) :
    ∃ a, closure (e '' { a' | (a, a') ∈ s }) ∈ 𝓝 b 
goal: ∃ a, closure (e '' {a' | (a, a') ∈ s}) ∈ 𝓝 b

full_name: uniformEmbedding_subtypeEmb
code: theorem uniformEmbedding_subtypeEmb (p : α → Prop) {e : α → β} (ue : UniformEmbedding e)
    (de : DenseEmbedding e) : UniformEmbedding (DenseEmbedding.subtypeEmb p e) 
goal: UniformEmbedding (DenseEmbedding.subtypeEmb p e)

full_name: UniformEmbedding.prod
code: theorem UniformEmbedding.prod {α' : Type*} {β' : Type*} [UniformSpace α'] [UniformSpace β']
    {e₁ : α → α'} {e₂ : β → β'} (h₁ : UniformEmbedding e₁) (h₂ : UniformEmbedding e₂) :
    UniformEmbedding fun p : α × β => (e₁ p.1, e₂ p.2) 
goal: UniformEmbedding fun p => (e₁ p.1, e₂ p.2)

full_name: isComplete_image_iff
code: /-- A set is complete iff its image under a uniform inducing map is complete. -/
theorem isComplete_image_iff {m : α → β} {s : Set α} (hm : UniformInducing m) :
    IsComplete (m '' s) ↔ IsComplete s 
goal: IsComplete (m '' s) ↔ IsComplete s

full_name: completeSpace_iff_isComplete_range
code: theorem completeSpace_iff_isComplete_range {f : α → β} (hf : UniformInducing f) :
    CompleteSpace α ↔ IsComplete (range f) 
goal: CompleteSpace α ↔ IsComplete (Set.range f)

full_name: UniformInducing.isComplete_range
code: theorem UniformInducing.isComplete_range [CompleteSpace α] {f : α → β} (hf : UniformInducing f) :
    IsComplete (range f) 
goal: IsComplete (Set.range f)

full_name: SeparationQuotient.completeSpace_iff
code: theorem SeparationQuotient.completeSpace_iff :
    CompleteSpace (SeparationQuotient α) ↔ CompleteSpace α 
goal: CompleteSpace (SeparationQuotient α) ↔ CompleteSpace α

full_name: SeparationQuotient.instCompleteSpace
code: instance SeparationQuotient.instCompleteSpace [CompleteSpace α] :
    CompleteSpace (SeparationQuotient α) 
goal: CompleteSpace (SeparationQuotient α)

full_name: completeSpace_congr
code: theorem completeSpace_congr {e : α ≃ β} (he : UniformEmbedding e) :
    CompleteSpace α ↔ CompleteSpace β 
goal: CompleteSpace α ↔ CompleteSpace β

full_name: completeSpace_coe_iff_isComplete
code: theorem completeSpace_coe_iff_isComplete {s : Set α} : CompleteSpace s ↔ IsComplete s 
goal: CompleteSpace ↑s ↔ IsComplete s

full_name: IsClosed.completeSpace_coe
code: theorem IsClosed.completeSpace_coe [CompleteSpace α] {s : Set α} (hs : IsClosed s) :
    CompleteSpace s 
goal: CompleteSpace ↑s

full_name: ULift.completeSpace
code: /-- The lift of a complete space to another universe is still complete. -/
instance ULift.completeSpace [h : CompleteSpace α] : CompleteSpace (ULift α) 
goal: CompleteSpace (ULift.{u_1, u} α)

full_name: completeSpace_extension
code: theorem completeSpace_extension {m : β → α} (hm : UniformInducing m) (dense : DenseRange m)
    (h : ∀ f : Filter β, Cauchy f → ∃ x : α, map m f ≤ 𝓝 x) : CompleteSpace α 
goal: CompleteSpace α

full_name: totallyBounded_image_iff
code: lemma totallyBounded_image_iff {f : α → β} {s : Set α} (hf : UniformInducing f) :
    TotallyBounded (f '' s) ↔ TotallyBounded s 
goal: TotallyBounded (f '' s) ↔ TotallyBounded s

full_name: totallyBounded_preimage
code: theorem totallyBounded_preimage {f : α → β} {s : Set β} (hf : UniformInducing f)
    (hs : TotallyBounded s) : TotallyBounded (f ⁻¹' s) 
goal: TotallyBounded (f ⁻¹' s)

full_name: CompleteSpace.sum
code: instance CompleteSpace.sum [CompleteSpace α] [CompleteSpace β] : CompleteSpace (α ⊕ β) 
goal: CompleteSpace (α ⊕ β)

full_name: uniformEmbedding_comap
code: theorem uniformEmbedding_comap {α : Type*} {β : Type*} {f : α → β} [u : UniformSpace β]
    (hf : Function.Injective f) : @UniformEmbedding α β (UniformSpace.comap f u) u f 
goal: UniformEmbedding f

full_name: Embedding.comapUniformSpace
code: /-- 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 Embedding.comapUniformSpace {α β} [TopologicalSpace α] [u : UniformSpace β] (f : α → β)
    (h : Embedding f) : UniformSpace α 
goal: UniformSpace α

full_name: Embedding.to_uniformEmbedding
code: theorem Embedding.to_uniformEmbedding {α β} [TopologicalSpace α] [u : UniformSpace β] (f : α → β)
    (h : Embedding f) : @UniformEmbedding α β (h.comapUniformSpace f) u f 
goal: UniformEmbedding f

full_name: _aux_Mathlib_Topology_UniformSpace_UniformEmbedding___unexpand_DenseInducing_extend_1
code: local notation "ψ" => DenseInducing.extend (UniformInducing.denseInducing h_e h_dense) f
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Topology_UniformSpace_UniformEmbedding___macroRules_termψ_1
code: local notation "ψ" => DenseInducing.extend (UniformInducing.denseInducing h_e h_dense) f
goal: Lean.Macro

full_name: uniformly_extend_exists
code: theorem uniformly_extend_exists [CompleteSpace γ] (a : α) : ∃ c, Tendsto f (comap e (𝓝 a)) (𝓝 c) 
goal: ∃ c, Filter.Tendsto f (Filter.comap e (𝓝 a)) (𝓝 c)

full_name: uniform_extend_subtype
code: theorem uniform_extend_subtype [CompleteSpace γ] {p : α → Prop} {e : α → β} {f : α → γ} {b : β}
    {s : Set α} (hf : UniformContinuous fun x : Subtype p => f x.val) (he : UniformEmbedding 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) 
goal: ∃ c, Filter.Tendsto f (Filter.comap e (𝓝 b)) (𝓝 c)

full_name: uniformly_extend_spec
code: theorem uniformly_extend_spec [CompleteSpace γ] (a : α) : Tendsto f (comap e (𝓝 a)) (𝓝 (ψ a)) 
goal: Filter.Tendsto f (Filter.comap e (𝓝 a)) (𝓝 (⋯.extend f a))

full_name: uniformContinuous_uniformly_extend
code: theorem uniformContinuous_uniformly_extend [CompleteSpace γ] : UniformContinuous ψ 
goal: UniformContinuous (⋯.extend f)

full_name: uniformly_extend_of_ind
code: theorem uniformly_extend_of_ind (b : β) : ψ (e b) = f b 
goal: ⋯.extend f (e b) = f b

full_name: uniformly_extend_unique
code: theorem uniformly_extend_unique {g : α → γ} (hg : ∀ b, g (e b) = f b) (hc : Continuous g) : ψ = g 
goal: ⋯.extend f = g