ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- eq_of_uniformity_basis
theorem eq_of_uniformity_basis {α : Type*} [UniformSpace α] [T0Space α] {ι : Sort*}
    {p : ι → Prop} {s : ι → Set (α × α)} (hs : (𝓤 α).HasBasis p s) {x y : α}
    (h : ∀ {i}, p i → (x, y) ∈ s i) : x = y 
Arguments: {α : Type u_1} [UniformSpace α] [T0Space α] {ι : Sort u_2} {p : ι → Prop} {s : ι → Set (α × α)} (hs : (𝓤 α).HasBasis p s) {x y : α} (h : ∀ {i : ι}, p i → (x, y) ∈ s i)
Goal: x = y
-- eq_of_forall_symmetric
theorem eq_of_forall_symmetric {α : Type*} [UniformSpace α] [T0Space α] {x y : α}
    (h : ∀ {V}, V ∈ 𝓤 α → SymmetricRel V → (x, y) ∈ V) : x = y 
Arguments: {α : Type u_1} [UniformSpace α] [T0Space α] {x y : α} (h : ∀ {V : Set (α × α)}, V ∈ 𝓤 α → SymmetricRel V → (x, y) ∈ V)
Goal: x = y
-- eq_of_clusterPt_uniformity
theorem eq_of_clusterPt_uniformity [T0Space α] {x y : α} (h : ClusterPt (x, y) (𝓤 α)) : x = y 
Arguments: {α : Type u} [UniformSpace α] [T0Space α] {x y : α} (h : ClusterPt (x, y) (𝓤 α))
Goal: x = y
-- Filter.Tendsto.inseparable_iff_uniformity
theorem Filter.Tendsto.inseparable_iff_uniformity {l : Filter β} [NeBot l] {f g : β → α} {a b : α}
    (ha : Tendsto f l (𝓝 a)) (hb : Tendsto g l (𝓝 b)) :
    Inseparable a b ↔ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α) 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] {l : Filter β} [l.NeBot] {f g : β → α} {a b : α} (ha : Filter.Tendsto f l (𝓝 a)) (hb : Filter.Tendsto g l (𝓝 b))
Goal: Inseparable a b ↔ Filter.Tendsto (fun x => (f x, g x)) l (𝓤 α)
-- isClosed_of_spaced_out
theorem isClosed_of_spaced_out [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α) {s : Set α}
    (hs : s.Pairwise fun x y => (x, y) ∉ V₀) : IsClosed s 
Arguments: {α : Type u} [UniformSpace α] [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α) {s : Set α} (hs : s.Pairwise fun x y => (x, y) ∉ V₀)
Goal: IsClosed s
-- isClosed_range_of_spaced_out
theorem isClosed_range_of_spaced_out {ι} [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α)
    {f : ι → α} (hf : Pairwise fun x y => (f x, f y) ∉ V₀) : IsClosed (range f) 
Arguments: {α : Type u} [UniformSpace α] {ι : Type u_1} [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α) {f : ι → α} (hf : Pairwise fun x y => (f x, f y) ∉ V₀)
Goal: IsClosed (Set.range f)
-- SeparationQuotient.comap_map_mk_uniformity
theorem comap_map_mk_uniformity : comap (Prod.map mk mk) (map (Prod.map mk mk) (𝓤 α)) = 𝓤 α 
Arguments: {α : Type u} [UniformSpace α]
Goal: Filter.comap (Prod.map SeparationQuotient.mk SeparationQuotient.mk)
    (Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (𝓤 α)) =
  𝓤 α
-- SeparationQuotient.uniformity_eq
theorem uniformity_eq : 𝓤 (SeparationQuotient α) = (𝓤 α).map (Prod.map mk mk) 
Arguments: {α : Type u} [UniformSpace α]
Goal: 𝓤 (SeparationQuotient α) = Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (𝓤 α)
-- SeparationQuotient.uniformContinuous_mk
theorem uniformContinuous_mk : UniformContinuous (mk : α → SeparationQuotient α) 
Arguments: {α : Type u} [UniformSpace α]
Goal: UniformContinuous SeparationQuotient.mk
-- SeparationQuotient.uniformContinuous_dom
theorem uniformContinuous_dom {f : SeparationQuotient α → β} :
    UniformContinuous f ↔ UniformContinuous (f ∘ mk) 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] [UniformSpace β] {f : SeparationQuotient α → β}
Goal: UniformContinuous f ↔ UniformContinuous (f ∘ SeparationQuotient.mk)
-- SeparationQuotient.uniformContinuous_dom₂
theorem uniformContinuous_dom₂ {f : SeparationQuotient α × SeparationQuotient β → γ} :
    UniformContinuous f ↔ UniformContinuous fun p : α × β ↦ f (mk p.1, mk p.2) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [UniformSpace α] [UniformSpace β] [UniformSpace γ] {f : SeparationQuotient α × SeparationQuotient β → γ}
Goal: UniformContinuous f ↔ UniformContinuous fun p => f (SeparationQuotient.mk p.1, SeparationQuotient.mk p.2)
-- SeparationQuotient.uniformContinuous_lift
theorem uniformContinuous_lift {f : α → β} (h : ∀ a b, Inseparable a b → f a = f b) :
    UniformContinuous (lift f h) ↔ UniformContinuous f 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] [UniformSpace β] {f : α → β} (h : ∀ (a b : α), Inseparable a b → f a = f b)
Goal: UniformContinuous (SeparationQuotient.lift f h) ↔ UniformContinuous f
-- SeparationQuotient.uniformContinuous_uncurry_lift₂
theorem uniformContinuous_uncurry_lift₂ {f : α → β → γ}
    (h : ∀ a c b d, Inseparable a b → Inseparable c d → f a c = f b d) :
    UniformContinuous (uncurry <| lift₂ f h) ↔ UniformContinuous (uncurry f) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [UniformSpace α] [UniformSpace β] [UniformSpace γ] {f : α → β → γ} (h : ∀ (a : α) (c : β) (b : α) (d : β), Inseparable a b → Inseparable c d → f a c = f b d)
Goal: UniformContinuous (Function.uncurry (SeparationQuotient.lift₂ f h)) ↔ UniformContinuous (Function.uncurry f)
-- SeparationQuotient.comap_mk_uniformity
theorem comap_mk_uniformity : (𝓤 (SeparationQuotient α)).comap (Prod.map mk mk) = 𝓤 α 
Arguments: {α : Type u} [UniformSpace α]
Goal: Filter.comap (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (𝓤 (SeparationQuotient α)) = 𝓤 α
-- SeparationQuotient.lift'_mk
theorem lift'_mk [T0Space β] {f : α → β} (h : UniformContinuous f) (a : α) :
    lift' f (mk a) = f a 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] [UniformSpace β] [T0Space β] {f : α → β} (h : UniformContinuous f) (a : α)
Goal: SeparationQuotient.lift' f (SeparationQuotient.mk a) = f a
-- SeparationQuotient.uniformContinuous_lift'
theorem uniformContinuous_lift' [T0Space β] (f : α → β) : UniformContinuous (lift' f) 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] [UniformSpace β] [T0Space β] (f : α → β)
Goal: UniformContinuous (SeparationQuotient.lift' f)
-- SeparationQuotient.map_mk
theorem map_mk {f : α → β} (h : UniformContinuous f) (a : α) : map f (mk a) = mk (f a) 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] [UniformSpace β] {f : α → β} (h : UniformContinuous f) (a : α)
Goal: SeparationQuotient.map f (SeparationQuotient.mk a) = SeparationQuotient.mk (f a)
-- SeparationQuotient.uniformContinuous_map
theorem uniformContinuous_map (f : α → β) : UniformContinuous (map f) 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] [UniformSpace β] (f : α → β)
Goal: UniformContinuous (SeparationQuotient.map f)
-- SeparationQuotient.map_unique
theorem map_unique {f : α → β} (hf : UniformContinuous f)
    {g : SeparationQuotient α → SeparationQuotient β} (comm : mk ∘ f = g ∘ mk) : map f = g 
Arguments: {α : Type u} {β : Type v} [UniformSpace α] [UniformSpace β] {f : α → β} (hf : UniformContinuous f) {g : SeparationQuotient α → SeparationQuotient β} (comm : SeparationQuotient.mk ∘ f = g ∘ SeparationQuotient.mk)
Goal: SeparationQuotient.map f = g
-- SeparationQuotient.map_id
@[simp]
theorem map_id : map (@id α) = id 
Arguments: {α : Type u} [UniformSpace α]
Goal: SeparationQuotient.map id = id
-- SeparationQuotient.map_comp
theorem map_comp {f : α → β} {g : β → γ} (hf : UniformContinuous f) (hg : UniformContinuous g) :
    map g ∘ map f = map (g ∘ f) 
Arguments: {α : Type u} {β : Type v} {γ : Type w} [UniformSpace α] [UniformSpace β] [UniformSpace γ] {f : α → β} {g : β → γ} (hf : UniformContinuous f) (hg : UniformContinuous g)
Goal: SeparationQuotient.map g ∘ SeparationQuotient.map f = SeparationQuotient.map (g ∘ f)
-- CauchyFilter.monotone_gen
theorem monotone_gen : Monotone (gen : Set (α × α) → _) 
Arguments: {α : Type u} [UniformSpace α]
Goal: Monotone CauchyFilter.gen
-- _private.Mathlib.Topology.UniformSpace.Completion.0.CauchyFilter.symm_gen
private theorem symm_gen : map Prod.swap ((𝓤 α).lift' gen) ≤ (𝓤 α).lift' gen 
Arguments: {α : Type u} [UniformSpace α]
Goal: Filter.map Prod.swap ((𝓤 α).lift' CauchyFilter.gen) ≤ (𝓤 α).lift' CauchyFilter.gen
-- _private.Mathlib.Topology.UniformSpace.Completion.0.CauchyFilter.compRel_gen_gen_subset_gen_compRel
private theorem compRel_gen_gen_subset_gen_compRel {s t : Set (α × α)} :
    compRel (gen s) (gen t) ⊆ (gen (compRel s t) : Set (CauchyFilter α × CauchyFilter α)) 
Arguments: {α : Type u} [UniformSpace α] {s t : Set (α × α)}
Goal: CauchyFilter.gen s ○ CauchyFilter.gen t ⊆ CauchyFilter.gen (s ○ t)
-- _private.Mathlib.Topology.UniformSpace.Completion.0.CauchyFilter.comp_gen
private theorem comp_gen : (((𝓤 α).lift' gen).lift' fun s => compRel s s) ≤ (𝓤 α).lift' gen 
Arguments: {α : Type u} [UniformSpace α]
Goal: (((𝓤 α).lift' CauchyFilter.gen).lift' fun s => s ○ s) ≤ (𝓤 α).lift' CauchyFilter.gen
-- CauchyFilter.mem_uniformity
theorem mem_uniformity {s : Set (CauchyFilter α × CauchyFilter α)} :
    s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, gen t ⊆ s 
Arguments: {α : Type u} [UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)}
Goal: s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, CauchyFilter.gen t ⊆ s
-- CauchyFilter.basis_uniformity
theorem basis_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s) :
    (𝓤 (CauchyFilter α)).HasBasis p (gen ∘ s) 
Arguments: {α : Type u} [UniformSpace α] {ι : Sort u_1} {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s)
Goal: (𝓤 (CauchyFilter α)).HasBasis p (CauchyFilter.gen ∘ s)
-- CauchyFilter.mem_uniformity'
theorem mem_uniformity' {s : Set (CauchyFilter α × CauchyFilter α)} :
    s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ f g : CauchyFilter α, t ∈ f.1 ×ˢ g.1 → (f, g) ∈ s 
Arguments: {α : Type u} [UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)}
Goal: s ∈ 𝓤 (CauchyFilter α) ↔ ∃ t ∈ 𝓤 α, ∀ (f g : CauchyFilter α), t ∈ ↑f ×ˢ ↑g → (f, g) ∈ s
-- CauchyFilter.uniformInducing_pureCauchy
theorem uniformInducing_pureCauchy : UniformInducing (pureCauchy : α → CauchyFilter α) 
Arguments: {α : Type u} [UniformSpace α]
Goal: UniformInducing CauchyFilter.pureCauchy
-- CauchyFilter.uniformEmbedding_pureCauchy
theorem uniformEmbedding_pureCauchy : UniformEmbedding (pureCauchy : α → CauchyFilter α) 
Arguments: {α : Type u} [UniformSpace α]
Goal: UniformEmbedding CauchyFilter.pureCauchy
-- CauchyFilter.denseRange_pureCauchy
theorem denseRange_pureCauchy : DenseRange (pureCauchy : α → CauchyFilter α) 
Arguments: {α : Type u} [UniformSpace α]
Goal: DenseRange CauchyFilter.pureCauchy
-- CauchyFilter.denseInducing_pureCauchy
theorem denseInducing_pureCauchy : DenseInducing (pureCauchy : α → CauchyFilter α) 
Arguments: {α : Type u} [UniformSpace α]
Goal: DenseInducing CauchyFilter.pureCauchy
-- CauchyFilter.denseEmbedding_pureCauchy
theorem denseEmbedding_pureCauchy : DenseEmbedding (pureCauchy : α → CauchyFilter α) 
Arguments: {α : Type u} [UniformSpace α]
Goal: DenseEmbedding CauchyFilter.pureCauchy
-- CauchyFilter.nonempty_cauchyFilter_iff
theorem nonempty_cauchyFilter_iff : Nonempty (CauchyFilter α) ↔ Nonempty α 
Arguments: {α : Type u} [UniformSpace α]
Goal: Nonempty (CauchyFilter α) ↔ Nonempty α
-- CauchyFilter.extend_pureCauchy
theorem extend_pureCauchy {f : α → β} (hf : UniformContinuous f) (a : α) :
    extend f (pureCauchy a) = f a 
Arguments: {α : Type u} [UniformSpace α] {β : Type v} [UniformSpace β] [T0Space β] {f : α → β} (hf : UniformContinuous f) (a : α)
Goal: CauchyFilter.extend f (CauchyFilter.pureCauchy a) = f a
-- CauchyFilter.uniformContinuous_extend
theorem uniformContinuous_extend {f : α → β} : UniformContinuous (extend f) 
Arguments: {α : Type u} [UniformSpace α] {β : Type v} [UniformSpace β] [CompleteSpace β] {f : α → β}
Goal: UniformContinuous (CauchyFilter.extend f)
-- CauchyFilter.inseparable_iff
theorem inseparable_iff {f g : CauchyFilter α} : Inseparable f g ↔ f.1 ×ˢ g.1 ≤ 𝓤 α 
Arguments: {α : Type u} [UniformSpace α] {f g : CauchyFilter α}
Goal: Inseparable f g ↔ ↑f ×ˢ ↑g ≤ 𝓤 α
-- CauchyFilter.inseparable_iff_of_le_nhds
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 
Arguments: {α : Type u} [UniformSpace α] {f g : CauchyFilter α} {a b : α} (ha : ↑f ≤ 𝓝 a) (hb : ↑g ≤ 𝓝 b)
Goal: Inseparable a b ↔ Inseparable f g
-- CauchyFilter.inseparable_lim_iff
theorem inseparable_lim_iff [CompleteSpace α] {f g : CauchyFilter α} :
    haveI := f.2.1.nonempty; Inseparable (lim f.1) (lim g.1) ↔ Inseparable f g 
Arguments: {α : Type u} [UniformSpace α] [CompleteSpace α] {f g : CauchyFilter α}
Goal: Inseparable (lim ↑f) (lim ↑g) ↔ Inseparable f g
-- CauchyFilter.cauchyFilter_eq
theorem cauchyFilter_eq {α : Type*} [UniformSpace α] [CompleteSpace α] [T0Space α]
    {f g : CauchyFilter α} :
    haveI := f.2.1.nonempty; lim f.1 = lim g.1 ↔ Inseparable f g 
Arguments: {α : Type u_1} [UniformSpace α] [CompleteSpace α] [T0Space α] {f g : CauchyFilter α}
Goal: lim ↑f = lim ↑g ↔ Inseparable f g
-- CauchyFilter.separated_pureCauchy_injective
theorem separated_pureCauchy_injective {α : Type*} [UniformSpace α] [T0Space α] :
    Function.Injective fun a : α => SeparationQuotient.mk (pureCauchy a) 
Arguments: {α : Type u_1} [UniformSpace α] [T0Space α]
Goal: Function.Injective fun a => SeparationQuotient.mk (CauchyFilter.pureCauchy a)
-- UniformSpace.Completion.coe_eq
protected theorem coe_eq : ((↑) : α → Completion α) = SeparationQuotient.mk ∘ pureCauchy 
Arguments: (α : Type u_1) [UniformSpace α]
Goal: ↑α = SeparationQuotient.mk ∘ CauchyFilter.pureCauchy
-- UniformSpace.Completion.uniformInducing_coe
theorem uniformInducing_coe : UniformInducing ((↑) : α → Completion α) 
Arguments: (α : Type u_1) [UniformSpace α]
Goal: UniformInducing ↑α
-- UniformSpace.Completion.comap_coe_eq_uniformity
theorem comap_coe_eq_uniformity :
    ((𝓤 _).comap fun p : α × α => ((p.1 : Completion α), (p.2 : Completion α))) = 𝓤 α 
Arguments: (α : Type u_1) [UniformSpace α]
Goal: Filter.comap (fun p => (↑α p.1, ↑α p.2)) (𝓤 (UniformSpace.Completion α)) = 𝓤 α
-- UniformSpace.Completion.denseRange_coe
theorem denseRange_coe : DenseRange ((↑) : α → Completion α) 
Arguments: {α : Type u_1} [UniformSpace α]
Goal: DenseRange ↑α
-- UniformSpace.Completion.nonempty_completion_iff
theorem nonempty_completion_iff : Nonempty (Completion α) ↔ Nonempty α 
Arguments: (α : Type u_1) [UniformSpace α]
Goal: Nonempty (UniformSpace.Completion α) ↔ Nonempty α
-- UniformSpace.Completion.uniformContinuous_coe
theorem uniformContinuous_coe : UniformContinuous ((↑) : α → Completion α) 
Arguments: (α : Type u_1) [UniformSpace α]
Goal: UniformContinuous ↑α
-- UniformSpace.Completion.continuous_coe
theorem continuous_coe : Continuous ((↑) : α → Completion α) 
Arguments: (α : Type u_1) [UniformSpace α]
Goal: Continuous ↑α
-- UniformSpace.Completion.uniformEmbedding_coe
theorem uniformEmbedding_coe [T0Space α] : UniformEmbedding ((↑) : α → Completion α) 
Arguments: (α : Type u_1) [UniformSpace α] [T0Space α]
Goal: UniformEmbedding ↑α
-- UniformSpace.Completion.coe_injective
theorem coe_injective [T0Space α] : Function.Injective ((↑) : α → Completion α) 
Arguments: (α : Type u_1) [UniformSpace α] [T0Space α]
Goal: Function.Injective ↑α
-- UniformSpace.Completion.denseInducing_coe
theorem denseInducing_coe : DenseInducing ((↑) : α → Completion α) 
Arguments: {α : Type u_1} [UniformSpace α]
Goal: DenseInducing ↑α
-- UniformSpace.Completion.denseEmbedding_coe
theorem denseEmbedding_coe [T0Space α] : DenseEmbedding ((↑) : α → Completion α) 
Arguments: {α : Type u_1} [UniformSpace α] [T0Space α]
Goal: DenseEmbedding ↑α
-- UniformSpace.Completion.denseRange_coe₂
theorem denseRange_coe₂ :
    DenseRange fun x : α × β => ((x.1 : Completion α), (x.2 : Completion β)) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β]
Goal: DenseRange fun x => (↑α x.1, ↑β x.2)
-- UniformSpace.Completion.denseRange_coe₃
theorem denseRange_coe₃ :
    DenseRange fun x : α × β × γ =>
      ((x.1 : Completion α), ((x.2.1 : Completion β), (x.2.2 : Completion γ))) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {γ : Type u_3} [UniformSpace γ]
Goal: DenseRange fun x => (↑α x.1, ↑β x.2.1, ↑γ x.2.2)
-- UniformSpace.Completion.induction_on
@[elab_as_elim]
theorem induction_on {p : Completion α → Prop} (a : Completion α) (hp : IsClosed { a | p a })
    (ih : ∀ a : α, p a) : p a 
Arguments: {α : Type u_1} [UniformSpace α] {p : UniformSpace.Completion α → Prop} (a : UniformSpace.Completion α) (hp : IsClosed {a | p a}) (ih : ∀ (a : α), p (↑α a))
Goal: p a
-- UniformSpace.Completion.induction_on₂
@[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 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {p : UniformSpace.Completion α → UniformSpace.Completion β → Prop} (a : UniformSpace.Completion α) (b : UniformSpace.Completion β) (hp : IsClosed {x | p x.1 x.2}) (ih : ∀ (a : α) (b : β), p (↑α a) (↑β b))
Goal: p a b
-- UniformSpace.Completion.induction_on₃
@[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 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {γ : Type u_3} [UniformSpace γ] {p : UniformSpace.Completion α → UniformSpace.Completion β → UniformSpace.Completion γ → Prop} (a : UniformSpace.Completion α) (b : UniformSpace.Completion β) (c : UniformSpace.Completion γ) (hp : IsClosed {x | p x.1 x.2.1 x.2.2}) (ih : ∀ (a : α) (b : β) (c : γ), p (↑α a) (↑β b) (↑γ c))
Goal: p a b c
-- UniformSpace.Completion.ext
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 
Arguments: {α : Type u_1} [UniformSpace α] {Y : Type u_4} [TopologicalSpace Y] [T2Space Y] {f g : UniformSpace.Completion α → Y} (hf : Continuous f) (hg : Continuous g) (h : ∀ (a : α), f (↑α a) = g (↑α a))
Goal: f = g
-- UniformSpace.Completion.ext'
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 
Arguments: {α : Type u_1} [UniformSpace α] {Y : Type u_4} [TopologicalSpace Y] [T2Space Y] {f g : UniformSpace.Completion α → Y} (hf : Continuous f) (hg : Continuous g) (h : ∀ (a : α), f (↑α a) = g (↑α a)) (a : UniformSpace.Completion α)
Goal: f a = g a
-- UniformSpace.Completion.uniformContinuous_extension
theorem uniformContinuous_extension : UniformContinuous (Completion.extension f) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β} [CompleteSpace β]
Goal: UniformContinuous (UniformSpace.Completion.extension f)
-- UniformSpace.Completion.continuous_extension
@[continuity, fun_prop]
theorem continuous_extension : Continuous (Completion.extension f) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β} [CompleteSpace β]
Goal: Continuous (UniformSpace.Completion.extension f)
-- UniformSpace.Completion.extension_coe
theorem extension_coe [T0Space β] (hf : UniformContinuous f) (a : α) :
    (Completion.extension f) a = f a 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β} [T0Space β] (hf : UniformContinuous f) (a : α)
Goal: UniformSpace.Completion.extension f (↑α a) = f a
-- UniformSpace.Completion.extension_unique
theorem extension_unique (hf : UniformContinuous f) {g : Completion α → β}
    (hg : UniformContinuous g) (h : ∀ a : α, f a = g (a : Completion α)) :
    Completion.extension f = g 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β} [T0Space β] [CompleteSpace β] (hf : UniformContinuous f) {g : UniformSpace.Completion α → β} (hg : UniformContinuous g) (h : ∀ (a : α), f a = g (↑α a))
Goal: UniformSpace.Completion.extension f = g
-- UniformSpace.Completion.extension_comp_coe
@[simp]
theorem extension_comp_coe {f : Completion α → β} (hf : UniformContinuous f) :
    Completion.extension (f ∘ (↑)) = f 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] [T0Space β] [CompleteSpace β] {f : UniformSpace.Completion α → β} (hf : UniformContinuous f)
Goal: UniformSpace.Completion.extension (f ∘ ↑α) = f
-- UniformSpace.Completion.uniformContinuous_map
theorem uniformContinuous_map : UniformContinuous (Completion.map f) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β}
Goal: UniformContinuous (UniformSpace.Completion.map f)
-- UniformSpace.Completion.continuous_map
@[continuity]
theorem continuous_map : Continuous (Completion.map f) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β}
Goal: Continuous (UniformSpace.Completion.map f)
-- UniformSpace.Completion.map_coe
theorem map_coe (hf : UniformContinuous f) (a : α) : (Completion.map f) a = f a 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β} (hf : UniformContinuous f) (a : α)
Goal: UniformSpace.Completion.map f (↑α a) = ↑β (f a)
-- UniformSpace.Completion.map_unique
theorem map_unique {f : α → β} {g : Completion α → Completion β} (hg : UniformContinuous g)
    (h : ∀ a : α, ↑(f a) = g a) : Completion.map f = g 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {f : α → β} {g : UniformSpace.Completion α → UniformSpace.Completion β} (hg : UniformContinuous g) (h : ∀ (a : α), ↑β (f a) = g (↑α a))
Goal: UniformSpace.Completion.map f = g
-- UniformSpace.Completion.map_id
@[simp]
theorem map_id : Completion.map (@id α) = id 
Arguments: {α : Type u_1} [UniformSpace α]
Goal: UniformSpace.Completion.map id = id
-- UniformSpace.Completion.extension_map
theorem extension_map [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β}
    (hf : UniformContinuous f) (hg : UniformContinuous g) :
    Completion.extension f ∘ Completion.map g = Completion.extension (f ∘ g) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {γ : Type u_3} [UniformSpace γ] [CompleteSpace γ] [T0Space γ] {f : β → γ} {g : α → β} (hf : UniformContinuous f) (hg : UniformContinuous g)
Goal: UniformSpace.Completion.extension f ∘ UniformSpace.Completion.map g = UniformSpace.Completion.extension (f ∘ g)
-- UniformSpace.Completion.map_comp
theorem map_comp {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f) :
    Completion.map g ∘ Completion.map f = Completion.map (g ∘ f) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {γ : Type u_3} [UniformSpace γ] {g : β → γ} {f : α → β} (hg : UniformContinuous g) (hf : UniformContinuous f)
Goal: UniformSpace.Completion.map g ∘ UniformSpace.Completion.map f = UniformSpace.Completion.map (g ∘ f)
-- UniformSpace.Completion.uniformContinuous_completionSeparationQuotientEquiv
theorem uniformContinuous_completionSeparationQuotientEquiv :
    UniformContinuous (completionSeparationQuotientEquiv α) 
Arguments: {α : Type u_1} [UniformSpace α]
Goal: UniformContinuous ⇑(UniformSpace.Completion.completionSeparationQuotientEquiv α)
-- UniformSpace.Completion.uniformContinuous_completionSeparationQuotientEquiv_symm
theorem uniformContinuous_completionSeparationQuotientEquiv_symm :
    UniformContinuous (completionSeparationQuotientEquiv α).symm 
Arguments: {α : Type u_1} [UniformSpace α]
Goal: UniformContinuous ⇑(UniformSpace.Completion.completionSeparationQuotientEquiv α).symm
-- UniformSpace.Completion.extension₂_coe_coe
theorem extension₂_coe_coe (hf : UniformContinuous₂ f) (a : α) (b : β) :
    Completion.extension₂ f a b = f a b 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {γ : Type u_3} [UniformSpace γ] {f : α → β → γ} [T0Space γ] (hf : UniformContinuous₂ f) (a : α) (b : β)
Goal: UniformSpace.Completion.extension₂ f (↑α a) (↑β b) = f a b
-- UniformSpace.Completion.uniformContinuous_extension₂
theorem uniformContinuous_extension₂ : UniformContinuous₂ (Completion.extension₂ f) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {γ : Type u_3} [UniformSpace γ] (f : α → β → γ) [CompleteSpace γ]
Goal: UniformContinuous₂ (UniformSpace.Completion.extension₂ f)
-- UniformSpace.Completion.uniformContinuous_map₂
theorem uniformContinuous_map₂ (f : α → β → γ) : UniformContinuous₂ (Completion.map₂ f) 
Arguments: {α : Type u_1} [UniformSpace α] {β : Type u_2} [UniformSpace β] {γ : Type u_3} [UniformSpace γ] (f : α → β → γ)
Goal: UniformContinuous₂ (UniformSpace.Completion.map₂ f)