File: Mathlib/Topology/UniformSpace/Separation.lean

full_name: UniformSpace.to_regularSpace
code: instance (priority := 100) UniformSpace.to_regularSpace : RegularSpace α 
goal: RegularSpace α

full_name: Filter.HasBasis.specializes_iff_uniformity
code: theorem Filter.HasBasis.specializes_iff_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)}
    (h : (𝓤 α).HasBasis p s) {x y : α} : x ⤳ y ↔ ∀ i, p i → (x, y) ∈ s i 
goal: x ⤳ y ↔ ∀ (i : ι), p i → (x, y) ∈ s i

full_name: Filter.HasBasis.inseparable_iff_uniformity
code: theorem Filter.HasBasis.inseparable_iff_uniformity {ι : Sort*} {p : ι → Prop} {s : ι → Set (α × α)}
    (h : (𝓤 α).HasBasis p s) {x y : α} : Inseparable x y ↔ ∀ i, p i → (x, y) ∈ s i 
goal: Inseparable x y ↔ ∀ (i : ι), p i → (x, y) ∈ s i

full_name: inseparable_iff_ker_uniformity
code: theorem inseparable_iff_ker_uniformity {x y : α} : Inseparable x y ↔ (x, y) ∈ (𝓤 α).ker 
goal: Inseparable x y ↔ (x, y) ∈ (𝓤 α).ker

full_name: Inseparable.nhds_le_uniformity
code: protected theorem Inseparable.nhds_le_uniformity {x y : α} (h : Inseparable x y) :
    𝓝 (x, y) ≤ 𝓤 α 
goal: 𝓝 (x, y) ≤ 𝓤 α

full_name: inseparable_iff_clusterPt_uniformity
code: theorem inseparable_iff_clusterPt_uniformity {x y : α} :
    Inseparable x y ↔ ClusterPt (x, y) (𝓤 α) 
goal: Inseparable x y ↔ ClusterPt (x, y) (𝓤 α)

full_name: t0Space_iff_uniformity
code: theorem t0Space_iff_uniformity :
    T0Space α ↔ ∀ x y, (∀ r ∈ 𝓤 α, (x, y) ∈ r) → x = y 
goal: T0Space α ↔ ∀ (x y : α), (∀ r ∈ 𝓤 α, (x, y) ∈ r) → x = y

full_name: t0Space_iff_uniformity'
code: theorem t0Space_iff_uniformity' :
    T0Space α ↔ Pairwise fun x y ↦ ∃ r ∈ 𝓤 α, (x, y) ∉ r 
goal: T0Space α ↔ Pairwise fun x y => ∃ r ∈ 𝓤 α, (x, y) ∉ r

full_name: t0Space_iff_ker_uniformity
code: theorem t0Space_iff_ker_uniformity : T0Space α ↔ (𝓤 α).ker = diagonal α 
goal: T0Space α ↔ (𝓤 α).ker = Set.diagonal α

full_name: eq_of_uniformity
code: theorem eq_of_uniformity {α : Type*} [UniformSpace α] [T0Space α] {x y : α}
    (h : ∀ {V}, V ∈ 𝓤 α → (x, y) ∈ V) : x = y 
goal: x = y

full_name: eq_of_uniformity_basis
code: 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 
goal: x = y

full_name: eq_of_forall_symmetric
code: theorem eq_of_forall_symmetric {α : Type*} [UniformSpace α] [T0Space α] {x y : α}
    (h : ∀ {V}, V ∈ 𝓤 α → SymmetricRel V → (x, y) ∈ V) : x = y 
goal: x = y

full_name: eq_of_clusterPt_uniformity
code: theorem eq_of_clusterPt_uniformity [T0Space α] {x y : α} (h : ClusterPt (x, y) (𝓤 α)) : x = y 
goal: x = y

full_name: Filter.Tendsto.inseparable_iff_uniformity
code: 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 (𝓤 α) 
goal: Inseparable a b ↔ Filter.Tendsto (fun x => (f x, g x)) l (𝓤 α)

full_name: isClosed_of_spaced_out
code: theorem isClosed_of_spaced_out [T0Space α] {V₀ : Set (α × α)} (V₀_in : V₀ ∈ 𝓤 α) {s : Set α}
    (hs : s.Pairwise fun x y => (x, y) ∉ V₀) : IsClosed s 
goal: IsClosed s

full_name: isClosed_range_of_spaced_out
code: 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) 
goal: IsClosed (Set.range f)

full_name: SeparationQuotient.comap_map_mk_uniformity
code: theorem comap_map_mk_uniformity : comap (Prod.map mk mk) (map (Prod.map mk mk) (𝓤 α)) = 𝓤 α 
goal: Filter.comap (Prod.map SeparationQuotient.mk SeparationQuotient.mk)
    (Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (𝓤 α)) =
  𝓤 α

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

full_name: SeparationQuotient.uniformity_eq
code: theorem uniformity_eq : 𝓤 (SeparationQuotient α) = (𝓤 α).map (Prod.map mk mk) 
goal: 𝓤 (SeparationQuotient α) = Filter.map (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (𝓤 α)

full_name: SeparationQuotient.uniformContinuous_mk
code: theorem uniformContinuous_mk : UniformContinuous (mk : α → SeparationQuotient α) 
goal: UniformContinuous SeparationQuotient.mk

full_name: SeparationQuotient.uniformContinuous_dom
code: theorem uniformContinuous_dom {f : SeparationQuotient α → β} :
    UniformContinuous f ↔ UniformContinuous (f ∘ mk) 
goal: UniformContinuous f ↔ UniformContinuous (f ∘ SeparationQuotient.mk)

full_name: SeparationQuotient.uniformContinuous_dom₂
code: theorem uniformContinuous_dom₂ {f : SeparationQuotient α × SeparationQuotient β → γ} :
    UniformContinuous f ↔ UniformContinuous fun p : α × β ↦ f (mk p.1, mk p.2) 
goal: UniformContinuous f ↔ UniformContinuous fun p => f (SeparationQuotient.mk p.1, SeparationQuotient.mk p.2)

full_name: SeparationQuotient.uniformContinuous_lift
code: theorem uniformContinuous_lift {f : α → β} (h : ∀ a b, Inseparable a b → f a = f b) :
    UniformContinuous (lift f h) ↔ UniformContinuous f 
goal: UniformContinuous (SeparationQuotient.lift f h) ↔ UniformContinuous f

full_name: SeparationQuotient.uniformContinuous_uncurry_lift₂
code: 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) 
goal: UniformContinuous (Function.uncurry (SeparationQuotient.lift₂ f h)) ↔ UniformContinuous (Function.uncurry f)

full_name: SeparationQuotient.comap_mk_uniformity
code: theorem comap_mk_uniformity : (𝓤 (SeparationQuotient α)).comap (Prod.map mk mk) = 𝓤 α 
goal: Filter.comap (Prod.map SeparationQuotient.mk SeparationQuotient.mk) (𝓤 (SeparationQuotient α)) = 𝓤 α

full_name: SeparationQuotient.lift'
code: /-- Factoring functions to a separated space through the separation quotient.

TODO: unify with `SeparationQuotient.lift`. -/
def lift' [T0Space β] (f : α → β) : SeparationQuotient α → β 
goal: SeparationQuotient α → β

full_name: SeparationQuotient.lift'_mk
code: theorem lift'_mk [T0Space β] {f : α → β} (h : UniformContinuous f) (a : α) :
    lift' f (mk a) = f a 
goal: SeparationQuotient.lift' f (SeparationQuotient.mk a) = f a

full_name: SeparationQuotient.uniformContinuous_lift'
code: theorem uniformContinuous_lift' [T0Space β] (f : α → β) : UniformContinuous (lift' f) 
goal: UniformContinuous (SeparationQuotient.lift' f)

full_name: SeparationQuotient.map
code: /-- The separation quotient functor acting on functions. -/
def map (f : α → β) : SeparationQuotient α → SeparationQuotient β 
goal: SeparationQuotient α → SeparationQuotient β

full_name: SeparationQuotient.map_mk
code: theorem map_mk {f : α → β} (h : UniformContinuous f) (a : α) : map f (mk a) = mk (f a) 
goal: SeparationQuotient.map f (SeparationQuotient.mk a) = SeparationQuotient.mk (f a)

full_name: SeparationQuotient.uniformContinuous_map
code: theorem uniformContinuous_map (f : α → β) : UniformContinuous (map f) 
goal: UniformContinuous (SeparationQuotient.map f)

full_name: SeparationQuotient.map_unique
code: theorem map_unique {f : α → β} (hf : UniformContinuous f)
    {g : SeparationQuotient α → SeparationQuotient β} (comm : mk ∘ f = g ∘ mk) : map f = g 
goal: SeparationQuotient.map f = g

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

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