File: Mathlib/Topology/UniformSpace/Completion.lean

full_name: CauchyFilter
code: /-- Space of Cauchy filters

This is essentially the completion of a uniform space. The embeddings are the neighbourhood filters.
This space is not minimal, the separated uniform space (i.e. quotiented on the intersection of all
entourages) is necessary for this.
-/
def CauchyFilter (α : Type u) [UniformSpace α] : Type u 
goal: Type u

full_name: CauchyFilter.instNeBotValFilterCauchy
code: instance (f : CauchyFilter α) : NeBot f.1 
goal: (↑f).NeBot

full_name: CauchyFilter.gen
code: /-- The pairs of Cauchy filters generated by a set. -/
def gen (s : Set (α × α)) : Set (CauchyFilter α × CauchyFilter α) 
goal: Set (CauchyFilter α × CauchyFilter α)

full_name: CauchyFilter.monotone_gen
code: theorem monotone_gen : Monotone (gen : Set (α × α) → _) 
goal: Monotone CauchyFilter.gen

full_name: _private.Mathlib.Topology.UniformSpace.Completion.0.CauchyFilter.symm_gen
code: private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lift' gen 
goal: Filter.map Prod.swap ((𝓤 α).lift' CauchyFilter.gen) ≤ (𝓤 α).lift' CauchyFilter.gen

full_name: _private.Mathlib.Topology.UniformSpace.Completion.0.CauchyFilter.compRel_gen_gen_subset_gen_compRel
code: private theorem compRel_gen_gen_subset_gen_compRel {s t : Set (α × α)} :
    compRel (gen s) (gen t) ⊆ (gen (compRel s t) : Set (CauchyFilter α × CauchyFilter α)) 
goal: CauchyFilter.gen s ○ CauchyFilter.gen t ⊆ CauchyFilter.gen (s ○ t)

full_name: _private.Mathlib.Topology.UniformSpace.Completion.0.CauchyFilter.comp_gen
code: private theorem comp_gen : (((𝓤 α).lift' gen).lift' fun s => compRel s s) ≤ (𝓤 α).lift' gen 
goal: (((𝓤 α).lift' CauchyFilter.gen).lift' fun s => s ○ s) ≤ (𝓤 α).lift' CauchyFilter.gen

full_name: CauchyFilter.instUniformSpace
code: instance : UniformSpace (CauchyFilter α) 
goal: UniformSpace (CauchyFilter α)

full_name: CauchyFilter.mem_uniformity
code: theorem mem_uniformity {s : Set (CauchyFilter α × CauchyFilter α)} :
    s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, gen t ⊆ s 
goal: s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, CauchyFilter.gen t ⊆ s

full_name: CauchyFilter.basis_uniformity
code: theorem basis_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s) :
    (𝓤 (CauchyFilter α)).HasBasis p (gen ∘ s) 
goal: (𝓤 (CauchyFilter α)).HasBasis p (CauchyFilter.gen ∘ s)

full_name: CauchyFilter.mem_uniformity'
code: theorem mem_uniformity' {s : Set (CauchyFilter α × CauchyFilter α)} :
    s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ˢ g.1 → (f, g) ∈ s 
goal: s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ (f g : CauchyFilter α), t ∈ ↑f ×ˢ ↑g → (f, g) ∈ s

full_name: CauchyFilter.pureCauchy
code: /-- Embedding of `α` into its completion `CauchyFilter α` -/
def pureCauchy (a : α) : CauchyFilter α 
goal: CauchyFilter α

full_name: CauchyFilter.uniformInducing_pureCauchy
code: theorem uniformInducing_pureCauchy : UniformInducing (pureCauchy : α → CauchyFilter α) 
goal: UniformInducing CauchyFilter.pureCauchy

full_name: CauchyFilter.uniformEmbedding_pureCauchy
code: theorem uniformEmbedding_pureCauchy : UniformEmbedding (pureCauchy : α → CauchyFilter α) 
goal: UniformEmbedding CauchyFilter.pureCauchy

full_name: CauchyFilter.denseRange_pureCauchy
code: theorem denseRange_pureCauchy : DenseRange (pureCauchy : α → CauchyFilter α) 
goal: DenseRange CauchyFilter.pureCauchy

full_name: CauchyFilter.denseInducing_pureCauchy
code: theorem denseInducing_pureCauchy : DenseInducing (pureCauchy : α → CauchyFilter α) 
goal: DenseInducing CauchyFilter.pureCauchy

full_name: CauchyFilter.denseEmbedding_pureCauchy
code: theorem denseEmbedding_pureCauchy : DenseEmbedding (pureCauchy : α → CauchyFilter α) 
goal: DenseEmbedding CauchyFilter.pureCauchy

full_name: CauchyFilter.nonempty_cauchyFilter_iff
code: theorem nonempty_cauchyFilter_iff : Nonempty (CauchyFilter α) ↔ Nonempty α 
goal: Nonempty (CauchyFilter α) ↔ Nonempty α

full_name: CauchyFilter.instCompleteSpace
code: instance : CompleteSpace (CauchyFilter α) 
goal: CompleteSpace (CauchyFilter α)

full_name: CauchyFilter.instInhabited
code: instance [Inhabited α] : Inhabited (CauchyFilter α) 
goal: Inhabited (CauchyFilter α)

full_name: CauchyFilter.instNonempty
code: instance [h : Nonempty α] : Nonempty (CauchyFilter α) 
goal: Nonempty (CauchyFilter α)

full_name: CauchyFilter.extend
code: /-- Extend a uniformly continuous function `α → β` to a function `CauchyFilter α → β`.
Outputs junk when `f` is not uniformly continuous. -/
def extend (f : α → β) : CauchyFilter α → β 
goal: CauchyFilter α → β

full_name: CauchyFilter.extend_pureCauchy
code: theorem extend_pureCauchy {f : α → β} (hf : UniformContinuous f) (a : α) :
    extend f (pureCauchy a) = f a 
goal: CauchyFilter.extend f (CauchyFilter.pureCauchy a) = f a

full_name: CauchyFilter.uniformContinuous_extend
code: theorem uniformContinuous_extend {f : α → β} : UniformContinuous (extend f) 
goal: UniformContinuous (CauchyFilter.extend f)

full_name: CauchyFilter.inseparable_iff
code: theorem inseparable_iff {f g : CauchyFilter α} : Inseparable f g ↔ f.1 ×ˢ g.1 ≤ 𝓤 α 
goal: Inseparable f g ↔ ↑f ×ˢ ↑g ≤ 𝓤 α

full_name: CauchyFilter.inseparable_iff_of_le_nhds
code: theorem inseparable_iff_of_le_nhds {f g : CauchyFilter α} {a b : α}
    (ha : f.1 ≤ 𝓝 a) (hb : g.1 ≤ 𝓝 b) : Inseparable a b ↔ Inseparable f g 
goal: Inseparable a b ↔ Inseparable f g

full_name: CauchyFilter.inseparable_lim_iff
code: theorem inseparable_lim_iff [CompleteSpace α] {f g : CauchyFilter α} :
    haveI := f.2.1.nonempty; Inseparable (lim f.1) (lim g.1) ↔ Inseparable f g 
goal: Inseparable (lim ↑f) (lim ↑g) ↔ Inseparable f g

full_name: CauchyFilter.cauchyFilter_eq
code: theorem cauchyFilter_eq {α : Type*} [UniformSpace α] [CompleteSpace α] [T0Space α]
    {f g : CauchyFilter α} :
    haveI := f.2.1.nonempty; lim f.1 = lim g.1 ↔ Inseparable f g 
goal: lim ↑f = lim ↑g ↔ Inseparable f g

full_name: CauchyFilter.separated_pureCauchy_injective
code: theorem separated_pureCauchy_injective {α : Type*} [UniformSpace α] [T0Space α] :
    Function.Injective fun a : α => SeparationQuotient.mk (pureCauchy a) 
goal: Function.Injective fun a => SeparationQuotient.mk (CauchyFilter.pureCauchy a)

full_name: UniformSpace.Completion
code: /-- Hausdorff completion of `α` -/
def Completion 
goal: Type u_1

full_name: UniformSpace.Completion.inhabited
code: instance inhabited [Inhabited α] : Inhabited (Completion α) 
goal: Inhabited (UniformSpace.Completion α)

full_name: UniformSpace.Completion.uniformSpace
code: instance uniformSpace : UniformSpace (Completion α) 
goal: UniformSpace (UniformSpace.Completion α)

full_name: UniformSpace.Completion.completeSpace
code: instance completeSpace : CompleteSpace (Completion α) 
goal: CompleteSpace (UniformSpace.Completion α)

full_name: UniformSpace.Completion.t0Space
code: instance t0Space : T0Space (Completion α) 
goal: T0Space (UniformSpace.Completion α)

full_name: UniformSpace.Completion.coe'
code: /-- The map from a uniform space to its completion.

porting note: this was added to create a target for the `@[coe]` attribute. -/
@[coe] def coe' : α → Completion α 
goal: α → UniformSpace.Completion α

full_name: UniformSpace.Completion.instCoe
code: /-- Automatic coercion from `α` to its completion. Not always injective. -/
instance : Coe α (Completion α) 
goal: Coe α (UniformSpace.Completion α)

full_name: UniformSpace.Completion.coe_eq
code: protected theorem coe_eq : ((↑) : α → Completion α) = SeparationQuotient.mk ∘ pureCauchy 
goal: ↑α = SeparationQuotient.mk ∘ CauchyFilter.pureCauchy

full_name: UniformSpace.Completion.uniformInducing_coe
code: theorem uniformInducing_coe : UniformInducing ((↑) : α → Completion α) 
goal: UniformInducing ↑α

full_name: UniformSpace.Completion.comap_coe_eq_uniformity
code: theorem comap_coe_eq_uniformity :
    ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α 
goal: Filter.comap (fun p => (↑α p.1, ↑α p.2)) (𝓤 (UniformSpace.Completion α)) = 𝓤 α

full_name: UniformSpace.Completion.denseRange_coe
code: theorem denseRange_coe : DenseRange ((↑) : α → Completion α) 
goal: DenseRange ↑α

full_name: UniformSpace.Completion.cPkg
code: /-- The Haudorff completion as an abstract completion. -/
def cPkg {α : Type*} [UniformSpace α] : AbstractCompletion α 
goal: AbstractCompletion α

full_name: UniformSpace.Completion.AbstractCompletion.inhabited
code: instance AbstractCompletion.inhabited : Inhabited (AbstractCompletion α) 
goal: Inhabited (AbstractCompletion α)

full_name: UniformSpace.Completion.nonempty_completion_iff
code: theorem nonempty_completion_iff : Nonempty (Completion α) ↔ Nonempty α 
goal: Nonempty (UniformSpace.Completion α) ↔ Nonempty α

full_name: UniformSpace.Completion.uniformContinuous_coe
code: theorem uniformContinuous_coe : UniformContinuous ((↑) : α → Completion α) 
goal: UniformContinuous ↑α

full_name: UniformSpace.Completion.continuous_coe
code: theorem continuous_coe : Continuous ((↑) : α → Completion α) 
goal: Continuous ↑α

full_name: UniformSpace.Completion.uniformEmbedding_coe
code: theorem uniformEmbedding_coe [T0Space α] : UniformEmbedding ((↑) : α → Completion α) 
goal: UniformEmbedding ↑α

full_name: UniformSpace.Completion.coe_injective
code: theorem coe_injective [T0Space α] : Function.Injective ((↑) : α → Completion α) 
goal: Function.Injective ↑α

full_name: UniformSpace.Completion.denseInducing_coe
code: theorem denseInducing_coe : DenseInducing ((↑) : α → Completion α) 
goal: DenseInducing ↑α

full_name: UniformSpace.Completion.UniformCompletion.completeEquivSelf
code: /-- The uniform bijection between a complete space and its uniform completion. -/
def UniformCompletion.completeEquivSelf [CompleteSpace α] [T0Space α] : Completion α ≃ᵤ α 
goal: UniformSpace.Completion α ≃ᵤ α

full_name: UniformSpace.Completion.separableSpace_completion
code: instance separableSpace_completion [SeparableSpace α] : SeparableSpace (Completion α) 
goal: TopologicalSpace.SeparableSpace (UniformSpace.Completion α)

full_name: UniformSpace.Completion.denseEmbedding_coe
code: theorem denseEmbedding_coe [T0Space α] : DenseEmbedding ((↑) : α → Completion α) 
goal: DenseEmbedding ↑α

full_name: UniformSpace.Completion.denseRange_coe₂
code: theorem denseRange_coe₂ :
    DenseRange fun x : α × β => ((x.1 : Completion α), (x.2 : Completion β)) 
goal: DenseRange fun x => (↑α x.1, ↑β x.2)

full_name: UniformSpace.Completion.denseRange_coe₃
code: theorem denseRange_coe₃ :
    DenseRange fun x : α × β × γ =>
      ((x.1 : Completion α), ((x.2.1 : Completion β), (x.2.2 : Completion γ))) 
goal: DenseRange fun x => (↑α x.1, ↑β x.2.1, ↑γ x.2.2)

full_name: UniformSpace.Completion.induction_on
code: @[elab_as_elim]
theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed { a | p a })
    (ih : ∀ a : α, p a) : p a 
goal: p a

full_name: UniformSpace.Completion.induction_on₂
code: @[elab_as_elim]
theorem induction_on₂ {p : Completion α → Completion β → Prop} (a : Completion α) (b : Completion β)
    (hp : IsClosed { x : Completion α × Completion β | p x.1 x.2 })
    (ih : ∀ (a : α) (b : β), p a b) : p a b 
goal: p a b

full_name: UniformSpace.Completion.induction_on₃
code: @[elab_as_elim]
theorem induction_on₃ {p : Completion α → Completion β → Completion γ → Prop} (a : Completion α)
    (b : Completion β) (c : Completion γ)
    (hp : IsClosed { x : Completion α × Completion β × Completion γ | p x.1 x.2.1 x.2.2 })
    (ih : ∀ (a : α) (b : β) (c : γ), p a b c) : p a b c 
goal: p a b c

full_name: UniformSpace.Completion.ext
code: theorem ext {Y : Type*} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
    (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) : f = g 
goal: f = g

full_name: UniformSpace.Completion.ext'
code: theorem ext' {Y : Type*} [TopologicalSpace Y] [T2Space Y] {f g : Completion α → Y}
    (hf : Continuous f) (hg : Continuous g) (h : ∀ a : α, f a = g a) (a : Completion α) :
    f a = g a 
goal: f a = g a

full_name: UniformSpace.Completion.extension
code: /-- "Extension" to the completion. It is defined for any map `f` but
returns an arbitrary constant value if `f` is not uniformly continuous -/
protected def extension (f : α → β) : Completion α → β 
goal: UniformSpace.Completion α → β

full_name: UniformSpace.Completion.uniformContinuous_extension
code: theorem uniformContinuous_extension : UniformContinuous (Completion.extension f) 
goal: UniformContinuous (UniformSpace.Completion.extension f)

full_name: UniformSpace.Completion.continuous_extension
code: @[continuity, fun_prop]
theorem continuous_extension : Continuous (Completion.extension f) 
goal: Continuous (UniformSpace.Completion.extension f)

full_name: UniformSpace.Completion.extension_coe
code: theorem extension_coe [T0Space β] (hf : UniformContinuous f) (a : α) :
    (Completion.extension f) a = f a 
goal: UniformSpace.Completion.extension f (↑α a) = f a

full_name: UniformSpace.Completion.extension_unique
code: theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
    (hg : UniformContinuous g) (h : ∀ a : α, f a = g (a : Completion α)) :
    Completion.extension f = g 
goal: UniformSpace.Completion.extension f = g

full_name: UniformSpace.Completion.extension_comp_coe
code: @[simp]
theorem extension_comp_coe {f : Completion α → β} (hf : UniformContinuous f) :
    Completion.extension (f ∘ (↑)) = f 
goal: UniformSpace.Completion.extension (f ∘ ↑α) = f

full_name: UniformSpace.Completion.map
code: /-- Completion functor acting on morphisms -/
protected def map (f : α → β) : Completion α → Completion β 
goal: UniformSpace.Completion α → UniformSpace.Completion β

full_name: UniformSpace.Completion.uniformContinuous_map
code: theorem uniformContinuous_map : UniformContinuous (Completion.map f) 
goal: UniformContinuous (UniformSpace.Completion.map f)

full_name: UniformSpace.Completion.continuous_map
code: @[continuity]
theorem continuous_map : Continuous (Completion.map f) 
goal: Continuous (UniformSpace.Completion.map f)

full_name: UniformSpace.Completion.map_coe
code: theorem map_coe (hf : UniformContinuous f) (a : α) : (Completion.map f) a = f a 
goal: UniformSpace.Completion.map f (↑α a) = ↑β (f a)

full_name: UniformSpace.Completion.map_unique
code: theorem map_unique {f : α → β} {g : Completion α → Completion β} (hg : UniformContinuous g)
    (h : ∀ a : α, ↑(f a) = g a) : Completion.map f = g 
goal: UniformSpace.Completion.map f = g

full_name: UniformSpace.Completion.map_id
code: @[simp]
theorem map_id : Completion.map (@id α) = id 
goal: UniformSpace.Completion.map id = id

full_name: UniformSpace.Completion.extension_map
code: theorem extension_map [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β}
    (hf : UniformContinuous f) (hg : UniformContinuous g) :
    Completion.extension f ∘ Completion.map g = Completion.extension (f ∘ g) 
goal: UniformSpace.Completion.extension f ∘ UniformSpace.Completion.map g = UniformSpace.Completion.extension (f ∘ g)

full_name: UniformSpace.Completion.map_comp
code: theorem map_comp {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f) :
    Completion.map g ∘ Completion.map f = Completion.map (g ∘ f) 
goal: UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f)

full_name: UniformSpace.Completion.completionSeparationQuotientEquiv
code: /-- The isomorphism between the completion of a uniform space and the completion of its separation
quotient. -/
def completionSeparationQuotientEquiv (α : Type u) [UniformSpace α] :
    Completion (SeparationQuotient α) ≃ Completion α 
goal: UniformSpace.Completion (SeparationQuotient α) ≃ UniformSpace.Completion α

full_name: UniformSpace.Completion.uniformContinuous_completionSeparationQuotientEquiv
code: theorem uniformContinuous_completionSeparationQuotientEquiv :
    UniformContinuous (completionSeparationQuotientEquiv α) 
goal: UniformContinuous ⇑(UniformSpace.Completion.completionSeparationQuotientEquiv α)

full_name: UniformSpace.Completion.uniformContinuous_completionSeparationQuotientEquiv_symm
code: theorem uniformContinuous_completionSeparationQuotientEquiv_symm :
    UniformContinuous (completionSeparationQuotientEquiv α).symm 
goal: UniformContinuous ⇑(UniformSpace.Completion.completionSeparationQuotientEquiv α).symm

full_name: UniformSpace.Completion.extension₂
code: /-- Extend a two variable map to the Hausdorff completions. -/
protected def extension₂ (f : α → β → γ) : Completion α → Completion β → γ 
goal: UniformSpace.Completion α → UniformSpace.Completion β → γ

full_name: UniformSpace.Completion.extension₂_coe_coe
code: theorem extension₂_coe_coe (hf : UniformContinuous₂ f) (a : α) (b : β) :
    Completion.extension₂ f a b = f a b 
goal: UniformSpace.Completion.extension₂ f (↑α a) (↑β b) = f a b

full_name: UniformSpace.Completion.uniformContinuous_extension₂
code: theorem uniformContinuous_extension₂ : UniformContinuous₂ (Completion.extension₂ f) 
goal: UniformContinuous₂ (UniformSpace.Completion.extension₂ f)

full_name: UniformSpace.Completion.map₂
code: /-- Lift a two variable map to the Hausdorff completions. -/
protected def map₂ (f : α → β → γ) : Completion α → Completion β → Completion γ 
goal: UniformSpace.Completion α → UniformSpace.Completion β → UniformSpace.Completion γ

full_name: UniformSpace.Completion.uniformContinuous_map₂
code: theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (Completion.map₂ f) 
goal: UniformContinuous₂ (UniformSpace.Completion.map₂ f)

full_name: UniformSpace.Completion.continuous_map₂
code: theorem continuous_map₂ {δ} [TopologicalSpace δ] {f : α → β → γ} {a : δ → Completion α}
    {b : δ → Completion β} (ha : Continuous a) (hb : Continuous b) :
    Continuous fun d : δ => Completion.map₂ f (a d) (b d) 
goal: Continuous fun d => UniformSpace.Completion.map₂ f (a d) (b d)

full_name: UniformSpace.Completion.map₂_coe_coe
code: theorem map₂_coe_coe (a : α) (b : β) (f : α → β → γ) (hf : UniformContinuous₂ f) :
    Completion.map₂ f (a : Completion α) (b : Completion β) = f a b 
goal: UniformSpace.Completion.map₂ f (↑α a) (↑β b) = ↑γ (f a b)