File: Mathlib/Topology/UniformSpace/Basic.lean

full_name: idRel
code: /-- The identity relation, or the graph of the identity function -/
def idRel {α : Type*} 
goal: Set (α × α)

full_name: mem_idRel
code: @[simp]
theorem mem_idRel {a b : α} : (a, b) ∈ @idRel α ↔ a = b 
goal: (a, b) ∈ idRel ↔ a = b

full_name: idRel_subset
code: @[simp]
theorem idRel_subset {s : Set (α × α)} : idRel ⊆ s ↔ ∀ a, (a, a) ∈ s 
goal: idRel ⊆ s ↔ ∀ (a : α), (a, a) ∈ s

full_name: compRel
code: /-- The composition of relations -/
def compRel (r₁ r₂ : Set (α × α)) 
goal: Set (α × α)

full_name: Uniformity._aux_Mathlib_Topology_UniformSpace_Basic___unexpand_compRel_1
code: @[inherit_doc]
scoped[Uniformity] infixl:62 " ○ " => compRel
goal: Lean.PrettyPrinter.Unexpander

full_name: Uniformity.«_aux_Mathlib_Topology_UniformSpace_Basic___macroRules_Uniformity_term_○__1»
code: @[inherit_doc]
scoped[Uniformity] infixl:62 " ○ " => compRel
goal: Lean.Macro

full_name: mem_compRel
code: @[simp]
theorem mem_compRel {α : Type u} {r₁ r₂ : Set (α × α)} {x y : α} :
    (x, y) ∈ r₁ ○ r₂ ↔ ∃ z, (x, z) ∈ r₁ ∧ (z, y) ∈ r₂ 
goal: (x, y) ∈ r₁ ○ r₂ ↔ ∃ z, (x, z) ∈ r₁ ∧ (z, y) ∈ r₂

full_name: swap_idRel
code: @[simp]
theorem swap_idRel : Prod.swap '' idRel = @idRel α 
goal: Prod.swap '' idRel = idRel

full_name: Monotone.compRel
code: theorem Monotone.compRel [Preorder β] {f g : β → Set (α × α)} (hf : Monotone f) (hg : Monotone g) :
    Monotone fun x => f x ○ g x 
goal: Monotone fun x => f x ○ g x

full_name: compRel_mono
code: @[mono, gcongr]
theorem compRel_mono {f g h k : Set (α × α)} (h₁ : f ⊆ h) (h₂ : g ⊆ k) : f ○ g ⊆ h ○ k 
goal: f ○ g ⊆ h ○ k

full_name: prod_mk_mem_compRel
code: theorem prod_mk_mem_compRel {a b c : α} {s t : Set (α × α)} (h₁ : (a, c) ∈ s) (h₂ : (c, b) ∈ t) :
    (a, b) ∈ s ○ t 
goal: (a, b) ∈ s ○ t

full_name: id_compRel
code: @[simp]
theorem id_compRel {r : Set (α × α)} : idRel ○ r = r 
goal: idRel ○ r = r

full_name: compRel_assoc
code: theorem compRel_assoc {r s t : Set (α × α)} : r ○ s ○ t = r ○ (s ○ t) 
goal: r ○ s ○ t = r ○ (s ○ t)

full_name: left_subset_compRel
code: theorem left_subset_compRel {s t : Set (α × α)} (h : idRel ⊆ t) : s ⊆ s ○ t 
goal: s ⊆ s ○ t

full_name: right_subset_compRel
code: theorem right_subset_compRel {s t : Set (α × α)} (h : idRel ⊆ s) : t ⊆ s ○ t 
goal: t ⊆ s ○ t

full_name: subset_comp_self
code: theorem subset_comp_self {s : Set (α × α)} (h : idRel ⊆ s) : s ⊆ s ○ s 
goal: s ⊆ s ○ s

full_name: subset_iterate_compRel
code: theorem subset_iterate_compRel {s t : Set (α × α)} (h : idRel ⊆ s) (n : ℕ) :
    t ⊆ (s ○ ·)^[n] t 
goal: t ⊆ (fun x => s ○ x)^[n] t

full_name: SymmetricRel
code: /-- The relation is invariant under swapping factors. -/
def SymmetricRel (V : Set (α × α)) : Prop 
goal: Prop

full_name: symmetrizeRel
code: /-- The maximal symmetric relation contained in a given relation. -/
def symmetrizeRel (V : Set (α × α)) : Set (α × α) 
goal: Set (α × α)

full_name: symmetric_symmetrizeRel
code: theorem symmetric_symmetrizeRel (V : Set (α × α)) : SymmetricRel (symmetrizeRel V) 
goal: SymmetricRel (symmetrizeRel V)

full_name: symmetrizeRel_subset_self
code: theorem symmetrizeRel_subset_self (V : Set (α × α)) : symmetrizeRel V ⊆ V 
goal: symmetrizeRel V ⊆ V

full_name: symmetrize_mono
code: @[mono]
theorem symmetrize_mono {V W : Set (α × α)} (h : V ⊆ W) : symmetrizeRel V ⊆ symmetrizeRel W 
goal: symmetrizeRel V ⊆ symmetrizeRel W

full_name: SymmetricRel.mk_mem_comm
code: theorem SymmetricRel.mk_mem_comm {V : Set (α × α)} (hV : SymmetricRel V) {x y : α} :
    (x, y) ∈ V ↔ (y, x) ∈ V 
goal: (x, y) ∈ V ↔ (y, x) ∈ V

full_name: SymmetricRel.eq
code: theorem SymmetricRel.eq {U : Set (α × α)} (hU : SymmetricRel U) : Prod.swap ⁻¹' U = U 
goal: Prod.swap ⁻¹' U = U

full_name: SymmetricRel.inter
code: theorem SymmetricRel.inter {U V : Set (α × α)} (hU : SymmetricRel U) (hV : SymmetricRel V) :
    SymmetricRel (U ∩ V) 
goal: SymmetricRel (U ∩ V)

full_name: UniformSpace.Core.comp
code: /-- This core description of a uniform space is outside of the type class hierarchy. It is useful
  for constructions of uniform spaces, when the topology is derived from the uniform space. -/
structure UniformSpace.Core (α : Type u) where
  /-- The uniformity filter. Once `UniformSpace` is defined, `𝓤 α` (`_root_.uniformity`) becomes the
  normal form. -/
  uniformity : Filter (α × α)
  /-- Every set in the uniformity filter includes the diagonal. -/
  refl : 𝓟 idRel ≤ uniformity
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
goal: (self.uniformity.lift' fun s => s ○ s) ≤ self.uniformity

full_name: UniformSpace.Core.uniformity
code: /-- This core description of a uniform space is outside of the type class hierarchy. It is useful
  for constructions of uniform spaces, when the topology is derived from the uniform space. -/
structure UniformSpace.Core (α : Type u) where
  /-- The uniformity filter. Once `UniformSpace` is defined, `𝓤 α` (`_root_.uniformity`) becomes the
  normal form. -/
  uniformity : Filter (α × α)
  /-- Every set in the uniformity filter includes the diagonal. -/
  refl : 𝓟 idRel ≤ uniformity
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
goal: Filter (α × α)

full_name: UniformSpace.Core.symm
code: /-- This core description of a uniform space is outside of the type class hierarchy. It is useful
  for constructions of uniform spaces, when the topology is derived from the uniform space. -/
structure UniformSpace.Core (α : Type u) where
  /-- The uniformity filter. Once `UniformSpace` is defined, `𝓤 α` (`_root_.uniformity`) becomes the
  normal form. -/
  uniformity : Filter (α × α)
  /-- Every set in the uniformity filter includes the diagonal. -/
  refl : 𝓟 idRel ≤ uniformity
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
goal: Filter.Tendsto Prod.swap self.uniformity self.uniformity

full_name: UniformSpace.Core
code: /-- This core description of a uniform space is outside of the type class hierarchy. It is useful
  for constructions of uniform spaces, when the topology is derived from the uniform space. -/
structure UniformSpace.Core (α : Type u) where
  /-- The uniformity filter. Once `UniformSpace` is defined, `𝓤 α` (`_root_.uniformity`) becomes the
  normal form. -/
  uniformity : Filter (α × α)
  /-- Every set in the uniformity filter includes the diagonal. -/
  refl : 𝓟 idRel ≤ uniformity
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
goal: Type u

full_name: UniformSpace.Core.refl
code: /-- This core description of a uniform space is outside of the type class hierarchy. It is useful
  for constructions of uniform spaces, when the topology is derived from the uniform space. -/
structure UniformSpace.Core (α : Type u) where
  /-- The uniformity filter. Once `UniformSpace` is defined, `𝓤 α` (`_root_.uniformity`) becomes the
  normal form. -/
  uniformity : Filter (α × α)
  /-- Every set in the uniformity filter includes the diagonal. -/
  refl : 𝓟 idRel ≤ uniformity
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
goal: 𝓟 idRel ≤ self.uniformity

full_name: UniformSpace.Core.comp_mem_uniformity_sets
code: protected theorem UniformSpace.Core.comp_mem_uniformity_sets {c : Core α} {s : Set (α × α)}
    (hs : s ∈ c.uniformity) : ∃ t ∈ c.uniformity, t ○ t ⊆ s 
goal: ∃ t ∈ c.uniformity, t ○ t ⊆ s

full_name: UniformSpace.Core.mk'
code: /-- An alternative constructor for `UniformSpace.Core`. This version unfolds various
`Filter`-related definitions. -/
def UniformSpace.Core.mk' {α : Type u} (U : Filter (α × α)) (refl : ∀ r ∈ U, ∀ (x), (x, x) ∈ r)
    (symm : ∀ r ∈ U, Prod.swap ⁻¹' r ∈ U) (comp : ∀ r ∈ U, ∃ t ∈ U, t ○ t ⊆ r) :
    UniformSpace.Core α 
goal: UniformSpace.Core α

full_name: UniformSpace.Core.mkOfBasis
code: /-- Defining a `UniformSpace.Core` from a filter basis satisfying some uniformity-like axioms. -/
def UniformSpace.Core.mkOfBasis {α : Type u} (B : FilterBasis (α × α))
    (refl : ∀ r ∈ B, ∀ (x), (x, x) ∈ r) (symm : ∀ r ∈ B, ∃ t ∈ B, t ⊆ Prod.swap ⁻¹' r)
    (comp : ∀ r ∈ B, ∃ t ∈ B, t ○ t ⊆ r) : UniformSpace.Core α 
goal: UniformSpace.Core α

full_name: UniformSpace.Core.toTopologicalSpace
code: /-- A uniform space generates a topological space -/
def UniformSpace.Core.toTopologicalSpace {α : Type u} (u : UniformSpace.Core α) :
    TopologicalSpace α 
goal: TopologicalSpace α

full_name: UniformSpace.Core.ext
code: theorem UniformSpace.Core.ext :
    ∀ {u₁ u₂ : UniformSpace.Core α}, u₁.uniformity = u₂.uniformity → u₁ = u₂
  
goal: u₁.uniformity = u₂.uniformity → u₁ = u₂

full_name: UniformSpace.Core.nhds_toTopologicalSpace
code: theorem UniformSpace.Core.nhds_toTopologicalSpace {α : Type u} (u : Core α) (x : α) :
    @nhds α u.toTopologicalSpace x = comap (Prod.mk x) u.uniformity 
goal: 𝓝 x = Filter.comap (Prod.mk x) u.uniformity

full_name: UniformSpace.nhds_eq_comap_uniformity
code: /-- A uniform space is a generalization of the "uniform" topological aspects of a
  metric space. It consists of a filter on `α × α` called the "uniformity", which
  satisfies properties analogous to the reflexivity, symmetry, and triangle properties
  of a metric.

  A metric space has a natural uniformity, and a uniform space has a natural topology.
  A topological group also has a natural uniformity, even when it is not metrizable. -/
class UniformSpace (α : Type u) extends TopologicalSpace α where
  /-- The uniformity filter. -/
  protected uniformity : Filter (α × α)
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  protected symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  protected comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
  /-- The uniformity agrees with the topology: the neighborhoods filter of each point `x`
  is equal to `Filter.comap (Prod.mk x) (𝓤 α)`. -/
  protected nhds_eq_comap_uniformity (x : α) : 𝓝 x = comap (Prod.mk x) uniformity
goal: 𝓝 x = Filter.comap (Prod.mk x) UniformSpace.uniformity

full_name: UniformSpace.symm
code: /-- A uniform space is a generalization of the "uniform" topological aspects of a
  metric space. It consists of a filter on `α × α` called the "uniformity", which
  satisfies properties analogous to the reflexivity, symmetry, and triangle properties
  of a metric.

  A metric space has a natural uniformity, and a uniform space has a natural topology.
  A topological group also has a natural uniformity, even when it is not metrizable. -/
class UniformSpace (α : Type u) extends TopologicalSpace α where
  /-- The uniformity filter. -/
  protected uniformity : Filter (α × α)
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  protected symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  protected comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
  /-- The uniformity agrees with the topology: the neighborhoods filter of each point `x`
  is equal to `Filter.comap (Prod.mk x) (𝓤 α)`. -/
  protected nhds_eq_comap_uniformity (x : α) : 𝓝 x = comap (Prod.mk x) uniformity
goal: Filter.Tendsto Prod.swap UniformSpace.uniformity UniformSpace.uniformity

full_name: UniformSpace.comp
code: /-- A uniform space is a generalization of the "uniform" topological aspects of a
  metric space. It consists of a filter on `α × α` called the "uniformity", which
  satisfies properties analogous to the reflexivity, symmetry, and triangle properties
  of a metric.

  A metric space has a natural uniformity, and a uniform space has a natural topology.
  A topological group also has a natural uniformity, even when it is not metrizable. -/
class UniformSpace (α : Type u) extends TopologicalSpace α where
  /-- The uniformity filter. -/
  protected uniformity : Filter (α × α)
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  protected symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  protected comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
  /-- The uniformity agrees with the topology: the neighborhoods filter of each point `x`
  is equal to `Filter.comap (Prod.mk x) (𝓤 α)`. -/
  protected nhds_eq_comap_uniformity (x : α) : 𝓝 x = comap (Prod.mk x) uniformity
goal: (UniformSpace.uniformity.lift' fun s => s ○ s) ≤ UniformSpace.uniformity

full_name: UniformSpace
code: /-- A uniform space is a generalization of the "uniform" topological aspects of a
  metric space. It consists of a filter on `α × α` called the "uniformity", which
  satisfies properties analogous to the reflexivity, symmetry, and triangle properties
  of a metric.

  A metric space has a natural uniformity, and a uniform space has a natural topology.
  A topological group also has a natural uniformity, even when it is not metrizable. -/
class UniformSpace (α : Type u) extends TopologicalSpace α where
  /-- The uniformity filter. -/
  protected uniformity : Filter (α × α)
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  protected symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  protected comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
  /-- The uniformity agrees with the topology: the neighborhoods filter of each point `x`
  is equal to `Filter.comap (Prod.mk x) (𝓤 α)`. -/
  protected nhds_eq_comap_uniformity (x : α) : 𝓝 x = comap (Prod.mk x) uniformity
goal: Type u

full_name: UniformSpace.uniformity
code: /-- A uniform space is a generalization of the "uniform" topological aspects of a
  metric space. It consists of a filter on `α × α` called the "uniformity", which
  satisfies properties analogous to the reflexivity, symmetry, and triangle properties
  of a metric.

  A metric space has a natural uniformity, and a uniform space has a natural topology.
  A topological group also has a natural uniformity, even when it is not metrizable. -/
class UniformSpace (α : Type u) extends TopologicalSpace α where
  /-- The uniformity filter. -/
  protected uniformity : Filter (α × α)
  /-- If `s ∈ uniformity`, then `Prod.swap ⁻¹' s ∈ uniformity`. -/
  protected symm : Tendsto Prod.swap uniformity uniformity
  /-- For every set `u ∈ uniformity`, there exists `v ∈ uniformity` such that `v ○ v ⊆ u`. -/
  protected comp : (uniformity.lift' fun s => s ○ s) ≤ uniformity
  /-- The uniformity agrees with the topology: the neighborhoods filter of each point `x`
  is equal to `Filter.comap (Prod.mk x) (𝓤 α)`. -/
  protected nhds_eq_comap_uniformity (x : α) : 𝓝 x = comap (Prod.mk x) uniformity
goal: Filter (α × α)

full_name: uniformity
code: /-- The uniformity is a filter on α × α (inferred from an ambient uniform space
  structure on α). -/
def uniformity (α : Type u) [UniformSpace α] : Filter (α × α) 
goal: Filter (α × α)

full_name: Uniformity.«_aux_Mathlib_Topology_UniformSpace_Basic___macroRules_Uniformity_term𝓤[_]_1»
code: /-- Notation for the uniformity filter with respect to a non-standard `UniformSpace` instance. -/
scoped[Uniformity] notation "𝓤[" u "]" => @uniformity _ u
goal: Lean.Macro

full_name: Uniformity._aux_Mathlib_Topology_UniformSpace_Basic___macroRules_Uniformity_term𝓤_1
code: @[inherit_doc] -- Porting note (#11215): TODO: should we drop the `uniformity` def?
scoped[Uniformity] notation "𝓤" => uniformity
goal: Lean.Macro

full_name: Uniformity._aux_Mathlib_Topology_UniformSpace_Basic___unexpand_uniformity_1
code: @[inherit_doc] -- Porting note (#11215): TODO: should we drop the `uniformity` def?
scoped[Uniformity] notation "𝓤" => uniformity
goal: Lean.PrettyPrinter.Unexpander

full_name: UniformSpace.ofCoreEq
code: /-- Construct a `UniformSpace` from a `u : UniformSpace.Core` and a `TopologicalSpace` structure
that is equal to `u.toTopologicalSpace`. -/
abbrev UniformSpace.ofCoreEq {α : Type u} (u : UniformSpace.Core α) (t : TopologicalSpace α)
    (h : t = u.toTopologicalSpace) : UniformSpace α 
goal: UniformSpace α

full_name: UniformSpace.ofCore
code: /-- Construct a `UniformSpace` from a `UniformSpace.Core`. -/
abbrev UniformSpace.ofCore {α : Type u} (u : UniformSpace.Core α) : UniformSpace α 
goal: UniformSpace α

full_name: UniformSpace.toCore
code: /-- Construct a `UniformSpace.Core` from a `UniformSpace`. -/
abbrev UniformSpace.toCore (u : UniformSpace α) : UniformSpace.Core α 
goal: UniformSpace.Core α

full_name: UniformSpace.toCore_toTopologicalSpace
code: theorem UniformSpace.toCore_toTopologicalSpace (u : UniformSpace α) :
    u.toCore.toTopologicalSpace = u.toTopologicalSpace 
goal: u.toCore.toTopologicalSpace = UniformSpace.toTopologicalSpace

full_name: UniformSpace.ofNhdsEqComap
code: /-- Build a `UniformSpace` from a `UniformSpace.Core` and a compatible topology.
Use `UniformSpace.mk` instead to avoid proving
the unnecessary assumption `UniformSpace.Core.refl`.

The main constructor used to use a different compatibility assumption.
This definition was created as a step towards porting to a new definition.
Now the main definition is ported,
so this constructor will be removed in a few months. -/
@[deprecated UniformSpace.mk (since := "2024-03-20")]
def UniformSpace.ofNhdsEqComap (u : UniformSpace.Core α) (_t : TopologicalSpace α)
    (h : ∀ x, 𝓝 x = u.uniformity.comap (Prod.mk x)) : UniformSpace α 
goal: UniformSpace α

full_name: UniformSpace.ext
code: @[ext]
protected theorem UniformSpace.ext {u₁ u₂ : UniformSpace α} (h : 𝓤[u₁] = 𝓤[u₂]) : u₁ = u₂ 
goal: u₁ = u₂

full_name: UniformSpace.ext_iff
code: protected theorem UniformSpace.ext_iff {u₁ u₂ : UniformSpace α} :
    u₁ = u₂ ↔ ∀ s, s ∈ 𝓤[u₁] ↔ s ∈ 𝓤[u₂] 
goal: u₁ = u₂ ↔ ∀ (s : Set (α × α)), s ∈ 𝓤 α ↔ s ∈ 𝓤 α

full_name: UniformSpace.ofCoreEq_toCore
code: theorem UniformSpace.ofCoreEq_toCore (u : UniformSpace α) (t : TopologicalSpace α)
    (h : t = u.toCore.toTopologicalSpace) : .ofCoreEq u.toCore t h = u 
goal: UniformSpace.ofCoreEq u.toCore t h = u

full_name: UniformSpace.replaceTopology
code: /-- Replace topology in a `UniformSpace` instance with a propositionally (but possibly not
definitionally) equal one. -/
abbrev UniformSpace.replaceTopology {α : Type*} [i : TopologicalSpace α] (u : UniformSpace α)
    (h : i = u.toTopologicalSpace) : UniformSpace α 
goal: UniformSpace α

full_name: UniformSpace.replaceTopology_eq
code: theorem UniformSpace.replaceTopology_eq {α : Type*} [i : TopologicalSpace α] (u : UniformSpace α)
    (h : i = u.toTopologicalSpace) : u.replaceTopology h = u 
goal: u.replaceTopology h = u

full_name: UniformSpace.ofFun
code: /-- Define a `UniformSpace` using a "distance" function. The function can be, e.g., the
distance in a (usual or extended) metric space or an absolute value on a ring. -/
def UniformSpace.ofFun {α : Type u} {β : Type v} [OrderedAddCommMonoid β]
    (d : α → α → β) (refl : ∀ x, d x x = 0) (symm : ∀ x y, d x y = d y x)
    (triangle : ∀ x y z, d x z ≤ d x y + d y z)
    (half : ∀ ε > (0 : β), ∃ δ > (0 : β), ∀ x < δ, ∀ y < δ, x + y < ε) :
    UniformSpace α 
goal: UniformSpace α

full_name: UniformSpace.hasBasis_ofFun
code: theorem UniformSpace.hasBasis_ofFun {α : Type u} {β : Type v} [LinearOrderedAddCommMonoid β]
    (h₀ : ∃ x : β, 0 < x) (d : α → α → β) (refl : ∀ x, d x x = 0) (symm : ∀ x y, d x y = d y x)
    (triangle : ∀ x y z, d x z ≤ d x y + d y z)
    (half : ∀ ε > (0 : β), ∃ δ > (0 : β), ∀ x < δ, ∀ y < δ, x + y < ε) :
    𝓤[.ofFun d refl symm triangle half].HasBasis ((0 : β) < ·) (fun ε => { x | d x.1 x.2 < ε }) 
goal: (𝓤 α).HasBasis (fun x => 0 < x) fun ε => {x | d x.1 x.2 < ε}

full_name: nhds_eq_comap_uniformity
code: theorem nhds_eq_comap_uniformity {x : α} : 𝓝 x = (𝓤 α).comap (Prod.mk x) 
goal: 𝓝 x = Filter.comap (Prod.mk x) (𝓤 α)

full_name: isOpen_uniformity
code: theorem isOpen_uniformity {s : Set α} :
    IsOpen s ↔ ∀ x ∈ s, { p : α × α | p.1 = x → p.2 ∈ s } ∈ 𝓤 α 
goal: IsOpen s ↔ ∀ x ∈ s, {p | p.1 = x → p.2 ∈ s} ∈ 𝓤 α

full_name: refl_le_uniformity
code: theorem refl_le_uniformity : 𝓟 idRel ≤ 𝓤 α 
goal: 𝓟 idRel ≤ 𝓤 α

full_name: uniformity.neBot
code: instance uniformity.neBot [Nonempty α] : NeBot (𝓤 α) 
goal: (𝓤 α).NeBot

full_name: refl_mem_uniformity
code: theorem refl_mem_uniformity {x : α} {s : Set (α × α)} (h : s ∈ 𝓤 α) : (x, x) ∈ s 
goal: (x, x) ∈ s

full_name: mem_uniformity_of_eq
code: theorem mem_uniformity_of_eq {x y : α} {s : Set (α × α)} (h : s ∈ 𝓤 α) (hx : x = y) : (x, y) ∈ s 
goal: (x, y) ∈ s

full_name: symm_le_uniformity
code: theorem symm_le_uniformity : map (@Prod.swap α α) (𝓤 _) ≤ 𝓤 _ 
goal: Filter.map Prod.swap (𝓤 α) ≤ 𝓤 α

full_name: comp_le_uniformity
code: theorem comp_le_uniformity : ((𝓤 α).lift' fun s : Set (α × α) => s ○ s) ≤ 𝓤 α 
goal: ((𝓤 α).lift' fun s => s ○ s) ≤ 𝓤 α

full_name: lift'_comp_uniformity
code: theorem lift'_comp_uniformity : ((𝓤 α).lift' fun s : Set (α × α) => s ○ s) = 𝓤 α 
goal: ((𝓤 α).lift' fun s => s ○ s) = 𝓤 α

full_name: tendsto_swap_uniformity
code: theorem tendsto_swap_uniformity : Tendsto (@Prod.swap α α) (𝓤 α) (𝓤 α) 
goal: Filter.Tendsto Prod.swap (𝓤 α) (𝓤 α)

full_name: comp_mem_uniformity_sets
code: theorem comp_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) : ∃ t ∈ 𝓤 α, t ○ t ⊆ s 
goal: ∃ t ∈ 𝓤 α, t ○ t ⊆ s

full_name: eventually_uniformity_iterate_comp_subset
code: /-- If `s ∈ 𝓤 α`, then for any natural `n`, for a subset `t` of a sufficiently small set in `𝓤 α`,
we have `t ○ t ○ ... ○ t ⊆ s` (`n` compositions). -/
theorem eventually_uniformity_iterate_comp_subset {s : Set (α × α)} (hs : s ∈ 𝓤 α) (n : ℕ) :
    ∀ᶠ t in (𝓤 α).smallSets, (t ○ ·)^[n] t ⊆ s 
goal: ∀ᶠ (t : Set (α × α)) in (𝓤 α).smallSets, (fun x => t ○ x)^[n] t ⊆ s

full_name: eventually_uniformity_comp_subset
code: /-- If `s ∈ 𝓤 α`, then for a subset `t` of a sufficiently small set in `𝓤 α`,
we have `t ○ t ⊆ s`. -/
theorem eventually_uniformity_comp_subset {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∀ᶠ t in (𝓤 α).smallSets, t ○ t ⊆ s 
goal: ∀ᶠ (t : Set (α × α)) in (𝓤 α).smallSets, t ○ t ⊆ s

full_name: Filter.Tendsto.uniformity_trans
code: /-- Relation `fun f g ↦ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α)` is transitive. -/
theorem Filter.Tendsto.uniformity_trans {l : Filter β} {f₁ f₂ f₃ : β → α}
    (h₁₂ : Tendsto (fun x => (f₁ x, f₂ x)) l (𝓤 α))
    (h₂₃ : Tendsto (fun x => (f₂ x, f₃ x)) l (𝓤 α)) : Tendsto (fun x => (f₁ x, f₃ x)) l (𝓤 α) 
goal: Filter.Tendsto (fun x => (f₁ x, f₃ x)) l (𝓤 α)

full_name: Filter.Tendsto.uniformity_symm
code: /-- Relation `fun f g ↦ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α)` is symmetric. -/
theorem Filter.Tendsto.uniformity_symm {l : Filter β} {f : β → α × α} (h : Tendsto f l (𝓤 α)) :
    Tendsto (fun x => ((f x).2, (f x).1)) l (𝓤 α) 
goal: Filter.Tendsto (fun x => ((f x).2, (f x).1)) l (𝓤 α)

full_name: tendsto_diag_uniformity
code: /-- Relation `fun f g ↦ Tendsto (fun x ↦ (f x, g x)) l (𝓤 α)` is reflexive. -/
theorem tendsto_diag_uniformity (f : β → α) (l : Filter β) :
    Tendsto (fun x => (f x, f x)) l (𝓤 α) 
goal: Filter.Tendsto (fun x => (f x, f x)) l (𝓤 α)

full_name: tendsto_const_uniformity
code: theorem tendsto_const_uniformity {a : α} {f : Filter β} : Tendsto (fun _ => (a, a)) f (𝓤 α) 
goal: Filter.Tendsto (fun x => (a, a)) f (𝓤 α)

full_name: symm_of_uniformity
code: theorem symm_of_uniformity {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, (∀ a b, (a, b) ∈ t → (b, a) ∈ t) ∧ t ⊆ s 
goal: ∃ t ∈ 𝓤 α, (∀ (a b : α), (a, b) ∈ t → (b, a) ∈ t) ∧ t ⊆ s

full_name: comp_symm_of_uniformity
code: theorem comp_symm_of_uniformity {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, (∀ {a b}, (a, b) ∈ t → (b, a) ∈ t) ∧ t ○ t ⊆ s 
goal: ∃ t ∈ 𝓤 α, (∀ {a b : α}, (a, b) ∈ t → (b, a) ∈ t) ∧ t ○ t ⊆ s

full_name: uniformity_le_symm
code: theorem uniformity_le_symm : 𝓤 α ≤ @Prod.swap α α <$> 𝓤 α 
goal: 𝓤 α ≤ Prod.swap <$> 𝓤 α

full_name: uniformity_eq_symm
code: theorem uniformity_eq_symm : 𝓤 α = @Prod.swap α α <$> 𝓤 α 
goal: 𝓤 α = Prod.swap <$> 𝓤 α

full_name: comap_swap_uniformity
code: @[simp]
theorem comap_swap_uniformity : comap (@Prod.swap α α) (𝓤 α) = 𝓤 α 
goal: Filter.comap Prod.swap (𝓤 α) = 𝓤 α

full_name: symmetrize_mem_uniformity
code: theorem symmetrize_mem_uniformity {V : Set (α × α)} (h : V ∈ 𝓤 α) : symmetrizeRel V ∈ 𝓤 α 
goal: symmetrizeRel V ∈ 𝓤 α

full_name: UniformSpace.hasBasis_symmetric
code: /-- Symmetric entourages form a basis of `𝓤 α` -/
theorem UniformSpace.hasBasis_symmetric :
    (𝓤 α).HasBasis (fun s : Set (α × α) => s ∈ 𝓤 α ∧ SymmetricRel s) id 
goal: (𝓤 α).HasBasis (fun s => s ∈ 𝓤 α ∧ SymmetricRel s) id

full_name: uniformity_lift_le_swap
code: theorem uniformity_lift_le_swap {g : Set (α × α) → Filter β} {f : Filter β} (hg : Monotone g)
    (h : ((𝓤 α).lift fun s => g (preimage Prod.swap s)) ≤ f) : (𝓤 α).lift g ≤ f 
goal: (𝓤 α).lift g ≤ f

full_name: uniformity_lift_le_comp
code: theorem uniformity_lift_le_comp {f : Set (α × α) → Filter β} (h : Monotone f) :
    ((𝓤 α).lift fun s => f (s ○ s)) ≤ (𝓤 α).lift f 
goal: ((𝓤 α).lift fun s => f (s ○ s)) ≤ (𝓤 α).lift f

full_name: comp3_mem_uniformity
code: theorem comp3_mem_uniformity {s : Set (α × α)} (hs : s ∈ 𝓤 α) : ∃ t ∈ 𝓤 α, t ○ (t ○ t) ⊆ s 
goal: ∃ t ∈ 𝓤 α, t ○ (t ○ t) ⊆ s

full_name: comp_le_uniformity3
code: /-- See also `comp3_mem_uniformity`. -/
theorem comp_le_uniformity3 : ((𝓤 α).lift' fun s : Set (α × α) => s ○ (s ○ s)) ≤ 𝓤 α 
goal: ((𝓤 α).lift' fun s => s ○ (s ○ s)) ≤ 𝓤 α

full_name: comp_symm_mem_uniformity_sets
code: /-- See also `comp_open_symm_mem_uniformity_sets`. -/
theorem comp_symm_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, SymmetricRel t ∧ t ○ t ⊆ s 
goal: ∃ t ∈ 𝓤 α, SymmetricRel t ∧ t ○ t ⊆ s

full_name: subset_comp_self_of_mem_uniformity
code: theorem subset_comp_self_of_mem_uniformity {s : Set (α × α)} (h : s ∈ 𝓤 α) : s ⊆ s ○ s 
goal: s ⊆ s ○ s

full_name: comp_comp_symm_mem_uniformity_sets
code: theorem comp_comp_symm_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, SymmetricRel t ∧ t ○ t ○ t ⊆ s 
goal: ∃ t ∈ 𝓤 α, SymmetricRel t ∧ t ○ t ○ t ⊆ s

full_name: UniformSpace.ball
code: /-- The ball around `(x : β)` with respect to `(V : Set (β × β))`. Intended to be
used for `V ∈ 𝓤 β`, but this is not needed for the definition. Recovers the
notions of metric space ball when `V = {p | dist p.1 p.2 < r }`.  -/
def UniformSpace.ball (x : β) (V : Set (β × β)) : Set β 
goal: Set β

full_name: UniformSpace.mem_ball_self
code: theorem UniformSpace.mem_ball_self (x : α) {V : Set (α × α)} (hV : V ∈ 𝓤 α) : x ∈ ball x V 
goal: x ∈ UniformSpace.ball x V

full_name: mem_ball_comp
code: /-- The triangle inequality for `UniformSpace.ball` -/
theorem mem_ball_comp {V W : Set (β × β)} {x y z} (h : y ∈ ball x V) (h' : z ∈ ball y W) :
    z ∈ ball x (V ○ W) 
goal: z ∈ UniformSpace.ball x (V ○ W)

full_name: ball_subset_of_comp_subset
code: theorem ball_subset_of_comp_subset {V W : Set (β × β)} {x y} (h : x ∈ ball y W) (h' : W ○ W ⊆ V) :
    ball x W ⊆ ball y V 
goal: UniformSpace.ball x W ⊆ UniformSpace.ball y V

full_name: ball_mono
code: theorem ball_mono {V W : Set (β × β)} (h : V ⊆ W) (x : β) : ball x V ⊆ ball x W 
goal: UniformSpace.ball x V ⊆ UniformSpace.ball x W

full_name: ball_inter
code: theorem ball_inter (x : β) (V W : Set (β × β)) : ball x (V ∩ W) = ball x V ∩ ball x W 
goal: UniformSpace.ball x (V ∩ W) = UniformSpace.ball x V ∩ UniformSpace.ball x W

full_name: ball_inter_left
code: theorem ball_inter_left (x : β) (V W : Set (β × β)) : ball x (V ∩ W) ⊆ ball x V 
goal: UniformSpace.ball x (V ∩ W) ⊆ UniformSpace.ball x V

full_name: ball_inter_right
code: theorem ball_inter_right (x : β) (V W : Set (β × β)) : ball x (V ∩ W) ⊆ ball x W 
goal: UniformSpace.ball x (V ∩ W) ⊆ UniformSpace.ball x W

full_name: mem_ball_symmetry
code: theorem mem_ball_symmetry {V : Set (β × β)} (hV : SymmetricRel V) {x y} :
    x ∈ ball y V ↔ y ∈ ball x V 
goal: x ∈ UniformSpace.ball y V ↔ y ∈ UniformSpace.ball x V

full_name: ball_eq_of_symmetry
code: theorem ball_eq_of_symmetry {V : Set (β × β)} (hV : SymmetricRel V) {x} :
    ball x V = { y | (y, x) ∈ V } 
goal: UniformSpace.ball x V = {y | (y, x) ∈ V}

full_name: mem_comp_of_mem_ball
code: theorem mem_comp_of_mem_ball {V W : Set (β × β)} {x y z : β} (hV : SymmetricRel V)
    (hx : x ∈ ball z V) (hy : y ∈ ball z W) : (x, y) ∈ V ○ W 
goal: (x, y) ∈ V ○ W

full_name: UniformSpace.isOpen_ball
code: theorem UniformSpace.isOpen_ball (x : α) {V : Set (α × α)} (hV : IsOpen V) : IsOpen (ball x V) 
goal: IsOpen (UniformSpace.ball x V)

full_name: UniformSpace.isClosed_ball
code: theorem UniformSpace.isClosed_ball (x : α) {V : Set (α × α)} (hV : IsClosed V) :
    IsClosed (ball x V) 
goal: IsClosed (UniformSpace.ball x V)

full_name: mem_comp_comp
code: theorem mem_comp_comp {V W M : Set (β × β)} (hW' : SymmetricRel W) {p : β × β} :
    p ∈ V ○ M ○ W ↔ (ball p.1 V ×ˢ ball p.2 W ∩ M).Nonempty 
goal: p ∈ V ○ M ○ W ↔ (UniformSpace.ball p.1 V ×ˢ UniformSpace.ball p.2 W ∩ M).Nonempty

full_name: mem_nhds_uniformity_iff_right
code: theorem mem_nhds_uniformity_iff_right {x : α} {s : Set α} :
    s ∈ 𝓝 x ↔ { p : α × α | p.1 = x → p.2 ∈ s } ∈ 𝓤 α 
goal: s ∈ 𝓝 x ↔ {p | p.1 = x → p.2 ∈ s} ∈ 𝓤 α

full_name: mem_nhds_uniformity_iff_left
code: theorem mem_nhds_uniformity_iff_left {x : α} {s : Set α} :
    s ∈ 𝓝 x ↔ { p : α × α | p.2 = x → p.1 ∈ s } ∈ 𝓤 α 
goal: s ∈ 𝓝 x ↔ {p | p.2 = x → p.1 ∈ s} ∈ 𝓤 α

full_name: nhdsWithin_eq_comap_uniformity_of_mem
code: theorem nhdsWithin_eq_comap_uniformity_of_mem {x : α} {T : Set α} (hx : x ∈ T) (S : Set α) :
    𝓝[S] x = (𝓤 α ⊓ 𝓟 (T ×ˢ S)).comap (Prod.mk x) 
goal: 𝓝[S] x = Filter.comap (Prod.mk x) (𝓤 α ⊓ 𝓟 (T ×ˢ S))

full_name: nhdsWithin_eq_comap_uniformity
code: theorem nhdsWithin_eq_comap_uniformity {x : α} (S : Set α) :
    𝓝[S] x = (𝓤 α ⊓ 𝓟 (univ ×ˢ S)).comap (Prod.mk x) 
goal: 𝓝[S] x = Filter.comap (Prod.mk x) (𝓤 α ⊓ 𝓟 (Set.univ ×ˢ S))

full_name: isOpen_iff_ball_subset
code: /-- See also `isOpen_iff_open_ball_subset`. -/
theorem isOpen_iff_ball_subset {s : Set α} : IsOpen s ↔ ∀ x ∈ s, ∃ V ∈ 𝓤 α, ball x V ⊆ s 
goal: IsOpen s ↔ ∀ x ∈ s, ∃ V ∈ 𝓤 α, UniformSpace.ball x V ⊆ s

full_name: nhds_basis_uniformity'
code: theorem nhds_basis_uniformity' {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s)
    {x : α} : (𝓝 x).HasBasis p fun i => ball x (s i) 
goal: (𝓝 x).HasBasis p fun i => UniformSpace.ball x (s i)

full_name: nhds_basis_uniformity
code: theorem nhds_basis_uniformity {p : ι → Prop} {s : ι → Set (α × α)} (h : (𝓤 α).HasBasis p s)
    {x : α} : (𝓝 x).HasBasis p fun i => { y | (y, x) ∈ s i } 
goal: (𝓝 x).HasBasis p fun i => {y | (y, x) ∈ s i}

full_name: nhds_eq_comap_uniformity'
code: theorem nhds_eq_comap_uniformity' {x : α} : 𝓝 x = (𝓤 α).comap fun y => (y, x) 
goal: 𝓝 x = Filter.comap (fun y => (y, x)) (𝓤 α)

full_name: UniformSpace.mem_nhds_iff
code: theorem UniformSpace.mem_nhds_iff {x : α} {s : Set α} : s ∈ 𝓝 x ↔ ∃ V ∈ 𝓤 α, ball x V ⊆ s 
goal: s ∈ 𝓝 x ↔ ∃ V ∈ 𝓤 α, UniformSpace.ball x V ⊆ s

full_name: UniformSpace.ball_mem_nhds
code: theorem UniformSpace.ball_mem_nhds (x : α) ⦃V : Set (α × α)⦄ (V_in : V ∈ 𝓤 α) : ball x V ∈ 𝓝 x 
goal: UniformSpace.ball x V ∈ 𝓝 x

full_name: UniformSpace.ball_mem_nhdsWithin
code: theorem UniformSpace.ball_mem_nhdsWithin {x : α} {S : Set α} ⦃V : Set (α × α)⦄ (x_in : x ∈ S)
    (V_in : V ∈ 𝓤 α ⊓ 𝓟 (S ×ˢ S)) : ball x V ∈ 𝓝[S] x 
goal: UniformSpace.ball x V ∈ 𝓝[S] x

full_name: UniformSpace.mem_nhds_iff_symm
code: theorem UniformSpace.mem_nhds_iff_symm {x : α} {s : Set α} :
    s ∈ 𝓝 x ↔ ∃ V ∈ 𝓤 α, SymmetricRel V ∧ ball x V ⊆ s 
goal: s ∈ 𝓝 x ↔ ∃ V ∈ 𝓤 α, SymmetricRel V ∧ UniformSpace.ball x V ⊆ s

full_name: UniformSpace.hasBasis_nhds
code: theorem UniformSpace.hasBasis_nhds (x : α) :
    HasBasis (𝓝 x) (fun s : Set (α × α) => s ∈ 𝓤 α ∧ SymmetricRel s) fun s => ball x s 
goal: (𝓝 x).HasBasis (fun s => s ∈ 𝓤 α ∧ SymmetricRel s) fun s => UniformSpace.ball x s

full_name: UniformSpace.mem_closure_iff_symm_ball
code: theorem UniformSpace.mem_closure_iff_symm_ball {s : Set α} {x} :
    x ∈ closure s ↔ ∀ {V}, V ∈ 𝓤 α → SymmetricRel V → (s ∩ ball x V).Nonempty 
goal: x ∈ closure s ↔ ∀ {V : Set (α × α)}, V ∈ 𝓤 α → SymmetricRel V → (s ∩ UniformSpace.ball x V).Nonempty

full_name: UniformSpace.mem_closure_iff_ball
code: theorem UniformSpace.mem_closure_iff_ball {s : Set α} {x} :
    x ∈ closure s ↔ ∀ {V}, V ∈ 𝓤 α → (ball x V ∩ s).Nonempty 
goal: x ∈ closure s ↔ ∀ {V : Set (α × α)}, V ∈ 𝓤 α → (UniformSpace.ball x V ∩ s).Nonempty

full_name: UniformSpace.hasBasis_nhds_prod
code: theorem UniformSpace.hasBasis_nhds_prod (x y : α) :
    HasBasis (𝓝 (x, y)) (fun s => s ∈ 𝓤 α ∧ SymmetricRel s) fun s => ball x s ×ˢ ball y s 
goal: (𝓝 (x, y)).HasBasis (fun s => s ∈ 𝓤 α ∧ SymmetricRel s) fun s => UniformSpace.ball x s ×ˢ UniformSpace.ball y s

full_name: nhds_eq_uniformity
code: theorem nhds_eq_uniformity {x : α} : 𝓝 x = (𝓤 α).lift' (ball x) 
goal: 𝓝 x = (𝓤 α).lift' (UniformSpace.ball x)

full_name: nhds_eq_uniformity'
code: theorem nhds_eq_uniformity' {x : α} : 𝓝 x = (𝓤 α).lift' fun s => { y | (y, x) ∈ s } 
goal: 𝓝 x = (𝓤 α).lift' fun s => {y | (y, x) ∈ s}

full_name: mem_nhds_left
code: theorem mem_nhds_left (x : α) {s : Set (α × α)} (h : s ∈ 𝓤 α) : { y : α | (x, y) ∈ s } ∈ 𝓝 x 
goal: {y | (x, y) ∈ s} ∈ 𝓝 x

full_name: mem_nhds_right
code: theorem mem_nhds_right (y : α) {s : Set (α × α)} (h : s ∈ 𝓤 α) : { x : α | (x, y) ∈ s } ∈ 𝓝 y 
goal: {x | (x, y) ∈ s} ∈ 𝓝 y

full_name: exists_mem_nhds_ball_subset_of_mem_nhds
code: theorem exists_mem_nhds_ball_subset_of_mem_nhds {a : α} {U : Set α} (h : U ∈ 𝓝 a) :
    ∃ V ∈ 𝓝 a, ∃ t ∈ 𝓤 α, ∀ a' ∈ V, UniformSpace.ball a' t ⊆ U 
goal: ∃ V ∈ 𝓝 a, ∃ t ∈ 𝓤 α, ∀ a' ∈ V, UniformSpace.ball a' t ⊆ U

full_name: tendsto_right_nhds_uniformity
code: theorem tendsto_right_nhds_uniformity {a : α} : Tendsto (fun a' => (a', a)) (𝓝 a) (𝓤 α) 
goal: Filter.Tendsto (fun a' => (a', a)) (𝓝 a) (𝓤 α)

full_name: tendsto_left_nhds_uniformity
code: theorem tendsto_left_nhds_uniformity {a : α} : Tendsto (fun a' => (a, a')) (𝓝 a) (𝓤 α) 
goal: Filter.Tendsto (fun a' => (a, a')) (𝓝 a) (𝓤 α)

full_name: lift_nhds_left
code: theorem lift_nhds_left {x : α} {g : Set α → Filter β} (hg : Monotone g) :
    (𝓝 x).lift g = (𝓤 α).lift fun s : Set (α × α) => g (ball x s) 
goal: (𝓝 x).lift g = (𝓤 α).lift fun s => g (UniformSpace.ball x s)

full_name: lift_nhds_right
code: theorem lift_nhds_right {x : α} {g : Set α → Filter β} (hg : Monotone g) :
    (𝓝 x).lift g = (𝓤 α).lift fun s : Set (α × α) => g { y | (y, x) ∈ s } 
goal: (𝓝 x).lift g = (𝓤 α).lift fun s => g {y | (y, x) ∈ s}

full_name: nhds_nhds_eq_uniformity_uniformity_prod
code: theorem nhds_nhds_eq_uniformity_uniformity_prod {a b : α} :
    𝓝 a ×ˢ 𝓝 b = (𝓤 α).lift fun s : Set (α × α) =>
      (𝓤 α).lift' fun t => { y : α | (y, a) ∈ s } ×ˢ { y : α | (b, y) ∈ t } 
goal: 𝓝 a ×ˢ 𝓝 b = (𝓤 α).lift fun s => (𝓤 α).lift' fun t => {y | (y, a) ∈ s} ×ˢ {y | (b, y) ∈ t}

full_name: nhds_eq_uniformity_prod
code: theorem nhds_eq_uniformity_prod {a b : α} :
    𝓝 (a, b) =
      (𝓤 α).lift' fun s : Set (α × α) => { y : α | (y, a) ∈ s } ×ˢ { y : α | (b, y) ∈ s } 
goal: 𝓝 (a, b) = (𝓤 α).lift' fun s => {y | (y, a) ∈ s} ×ˢ {y | (b, y) ∈ s}

full_name: nhdset_of_mem_uniformity
code: theorem nhdset_of_mem_uniformity {d : Set (α × α)} (s : Set (α × α)) (hd : d ∈ 𝓤 α) :
    ∃ t : Set (α × α), IsOpen t ∧ s ⊆ t ∧
      t ⊆ { p | ∃ x y, (p.1, x) ∈ d ∧ (x, y) ∈ s ∧ (y, p.2) ∈ d } 
goal: ∃ t, IsOpen t ∧ s ⊆ t ∧ t ⊆ {p | ∃ x y, (p.1, x) ∈ d ∧ (x, y) ∈ s ∧ (y, p.2) ∈ d}

full_name: nhds_le_uniformity
code: /-- Entourages are neighborhoods of the diagonal. -/
theorem nhds_le_uniformity (x : α) : 𝓝 (x, x) ≤ 𝓤 α 
goal: 𝓝 (x, x) ≤ 𝓤 α

full_name: iSup_nhds_le_uniformity
code: /-- Entourages are neighborhoods of the diagonal. -/
theorem iSup_nhds_le_uniformity : ⨆ x : α, 𝓝 (x, x) ≤ 𝓤 α 
goal: ⨆ x, 𝓝 (x, x) ≤ 𝓤 α

full_name: nhdsSet_diagonal_le_uniformity
code: /-- Entourages are neighborhoods of the diagonal. -/
theorem nhdsSet_diagonal_le_uniformity : 𝓝ˢ (diagonal α) ≤ 𝓤 α 
goal: 𝓝ˢ (Set.diagonal α) ≤ 𝓤 α

full_name: closure_eq_uniformity
code: theorem closure_eq_uniformity (s : Set <| α × α) :
    closure s = ⋂ V ∈ { V | V ∈ 𝓤 α ∧ SymmetricRel V }, V ○ s ○ V 
goal: closure s = ⋂ V ∈ {V | V ∈ 𝓤 α ∧ SymmetricRel V}, V ○ s ○ V

full_name: uniformity_hasBasis_closed
code: theorem uniformity_hasBasis_closed :
    HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α ∧ IsClosed V) id 
goal: (𝓤 α).HasBasis (fun V => V ∈ 𝓤 α ∧ IsClosed V) id

full_name: uniformity_eq_uniformity_closure
code: theorem uniformity_eq_uniformity_closure : 𝓤 α = (𝓤 α).lift' closure 
goal: 𝓤 α = (𝓤 α).lift' closure

full_name: Filter.HasBasis.uniformity_closure
code: theorem Filter.HasBasis.uniformity_closure {p : ι → Prop} {U : ι → Set (α × α)}
    (h : (𝓤 α).HasBasis p U) : (𝓤 α).HasBasis p fun i => closure (U i) 
goal: (𝓤 α).HasBasis p fun i => closure (U i)

full_name: uniformity_hasBasis_closure
code: /-- Closed entourages form a basis of the uniformity filter. -/
theorem uniformity_hasBasis_closure : HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α) closure 
goal: (𝓤 α).HasBasis (fun V => V ∈ 𝓤 α) closure

full_name: closure_eq_inter_uniformity
code: theorem closure_eq_inter_uniformity {t : Set (α × α)} : closure t = ⋂ d ∈ 𝓤 α, d ○ (t ○ d) 
goal: closure t = ⋂ d ∈ 𝓤 α, d ○ (t ○ d)

full_name: uniformity_eq_uniformity_interior
code: theorem uniformity_eq_uniformity_interior : 𝓤 α = (𝓤 α).lift' interior 
goal: 𝓤 α = (𝓤 α).lift' interior

full_name: interior_mem_uniformity
code: theorem interior_mem_uniformity {s : Set (α × α)} (hs : s ∈ 𝓤 α) : interior s ∈ 𝓤 α 
goal: interior s ∈ 𝓤 α

full_name: mem_uniformity_isClosed
code: theorem mem_uniformity_isClosed {s : Set (α × α)} (h : s ∈ 𝓤 α) : ∃ t ∈ 𝓤 α, IsClosed t ∧ t ⊆ s 
goal: ∃ t ∈ 𝓤 α, IsClosed t ∧ t ⊆ s

full_name: isOpen_iff_open_ball_subset
code: theorem isOpen_iff_open_ball_subset {s : Set α} :
    IsOpen s ↔ ∀ x ∈ s, ∃ V ∈ 𝓤 α, IsOpen V ∧ ball x V ⊆ s 
goal: IsOpen s ↔ ∀ x ∈ s, ∃ V ∈ 𝓤 α, IsOpen V ∧ UniformSpace.ball x V ⊆ s

full_name: Dense.biUnion_uniformity_ball
code: /-- The uniform neighborhoods of all points of a dense set cover the whole space. -/
theorem Dense.biUnion_uniformity_ball {s : Set α} {U : Set (α × α)} (hs : Dense s) (hU : U ∈ 𝓤 α) :
    ⋃ x ∈ s, ball x U = univ 
goal: ⋃ x ∈ s, UniformSpace.ball x U = Set.univ

full_name: DenseRange.iUnion_uniformity_ball
code: /-- The uniform neighborhoods of all points of a dense indexed collection cover the whole space. -/
lemma DenseRange.iUnion_uniformity_ball {ι : Type*} {xs : ι → α}
    (xs_dense : DenseRange xs) {U : Set (α × α)} (hU : U ∈ uniformity α) :
    ⋃ i, UniformSpace.ball (xs i) U = univ 
goal: ⋃ i, UniformSpace.ball (xs i) U = Set.univ

full_name: uniformity_hasBasis_open
code: /-- Open elements of `𝓤 α` form a basis of `𝓤 α`. -/
theorem uniformity_hasBasis_open : HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α ∧ IsOpen V) id 
goal: (𝓤 α).HasBasis (fun V => V ∈ 𝓤 α ∧ IsOpen V) id

full_name: Filter.HasBasis.mem_uniformity_iff
code: theorem Filter.HasBasis.mem_uniformity_iff {p : β → Prop} {s : β → Set (α × α)}
    (h : (𝓤 α).HasBasis p s) {t : Set (α × α)} :
    t ∈ 𝓤 α ↔ ∃ i, p i ∧ ∀ a b, (a, b) ∈ s i → (a, b) ∈ t 
goal: t ∈ 𝓤 α ↔ ∃ i, p i ∧ ∀ (a b : α), (a, b) ∈ s i → (a, b) ∈ t

full_name: uniformity_hasBasis_open_symmetric
code: /-- Open elements `s : Set (α × α)` of `𝓤 α` such that `(x, y) ∈ s ↔ (y, x) ∈ s` form a basis
of `𝓤 α`. -/
theorem uniformity_hasBasis_open_symmetric :
    HasBasis (𝓤 α) (fun V : Set (α × α) => V ∈ 𝓤 α ∧ IsOpen V ∧ SymmetricRel V) id 
goal: (𝓤 α).HasBasis (fun V => V ∈ 𝓤 α ∧ IsOpen V ∧ SymmetricRel V) id

full_name: comp_open_symm_mem_uniformity_sets
code: theorem comp_open_symm_mem_uniformity_sets {s : Set (α × α)} (hs : s ∈ 𝓤 α) :
    ∃ t ∈ 𝓤 α, IsOpen t ∧ SymmetricRel t ∧ t ○ t ⊆ s 
goal: ∃ t ∈ 𝓤 α, IsOpen t ∧ SymmetricRel t ∧ t ○ t ⊆ s

full_name: UniformSpace.has_seq_basis
code: theorem UniformSpace.has_seq_basis [IsCountablyGenerated <| 𝓤 α] :
    ∃ V : ℕ → Set (α × α), HasAntitoneBasis (𝓤 α) V ∧ ∀ n, SymmetricRel (V n) 
goal: ∃ V, (𝓤 α).HasAntitoneBasis V ∧ ∀ (n : ℕ), SymmetricRel (V n)

full_name: Filter.HasBasis.biInter_biUnion_ball
code: theorem Filter.HasBasis.biInter_biUnion_ball {p : ι → Prop} {U : ι → Set (α × α)}
    (h : HasBasis (𝓤 α) p U) (s : Set α) :
    (⋂ (i) (_ : p i), ⋃ x ∈ s, ball x (U i)) = closure s 
goal: ⋂ i, ⋂ (_ : p i), ⋃ x ∈ s, UniformSpace.ball x (U i) = closure s

full_name: UniformContinuous
code: /-- A function `f : α → β` is *uniformly continuous* if `(f x, f y)` tends to the diagonal
as `(x, y)` tends to the diagonal. In other words, if `x` is sufficiently close to `y`, then
`f x` is close to `f y` no matter where `x` and `y` are located in `α`. -/
def UniformContinuous [UniformSpace β] (f : α → β) 
goal: Prop

full_name: Uniformity.«_aux_Mathlib_Topology_UniformSpace_Basic___macroRules_Uniformity_termUniformContinuous[_,_]_1»
code: /-- Notation for uniform continuity with respect to non-standard `UniformSpace` instances. -/
scoped[Uniformity] notation "UniformContinuous[" u₁ ", " u₂ "]" => @UniformContinuous _ _ u₁ u₂
goal: Lean.Macro

full_name: UniformContinuousOn
code: /-- A function `f : α → β` is *uniformly continuous* on `s : Set α` if `(f x, f y)` tends to
the diagonal as `(x, y)` tends to the diagonal while remaining in `s ×ˢ s`.
In other words, if `x` is sufficiently close to `y`, then `f x` is close to
`f y` no matter where `x` and `y` are located in `s`. -/
def UniformContinuousOn [UniformSpace β] (f : α → β) (s : Set α) : Prop 
goal: Prop

full_name: uniformContinuous_def
code: theorem uniformContinuous_def [UniformSpace β] {f : α → β} :
    UniformContinuous f ↔ ∀ r ∈ 𝓤 β, { x : α × α | (f x.1, f x.2) ∈ r } ∈ 𝓤 α 
goal: UniformContinuous f ↔ ∀ r ∈ 𝓤 β, {x | (f x.1, f x.2) ∈ r} ∈ 𝓤 α

full_name: uniformContinuous_iff_eventually
code: theorem uniformContinuous_iff_eventually [UniformSpace β] {f : α → β} :
    UniformContinuous f ↔ ∀ r ∈ 𝓤 β, ∀ᶠ x : α × α in 𝓤 α, (f x.1, f x.2) ∈ r 
goal: UniformContinuous f ↔ ∀ r ∈ 𝓤 β, ∀ᶠ (x : α × α) in 𝓤 α, (f x.1, f x.2) ∈ r

full_name: uniformContinuousOn_univ
code: theorem uniformContinuousOn_univ [UniformSpace β] {f : α → β} :
    UniformContinuousOn f univ ↔ UniformContinuous f 
goal: UniformContinuousOn f Set.univ ↔ UniformContinuous f

full_name: uniformContinuous_of_const
code: theorem uniformContinuous_of_const [UniformSpace β] {c : α → β} (h : ∀ a b, c a = c b) :
    UniformContinuous c 
goal: UniformContinuous c

full_name: uniformContinuous_id
code: theorem uniformContinuous_id : UniformContinuous (@id α) 
goal: UniformContinuous id

full_name: uniformContinuous_const
code: theorem uniformContinuous_const [UniformSpace β] {b : β} : UniformContinuous fun _ : α => b 
goal: UniformContinuous fun x => b

full_name: UniformContinuous.comp
code: nonrec theorem UniformContinuous.comp [UniformSpace β] [UniformSpace γ] {g : β → γ} {f : α → β}
    (hg : UniformContinuous g) (hf : UniformContinuous f) : UniformContinuous (g ∘ f) 
goal: UniformContinuous (g ∘ f)

full_name: UniformContinuous.iterate
code: /--If a function `T` is uniformly continuous in a uniform space `β`,
then its `n`-th iterate `T^[n]` is also uniformly continuous.-/
theorem UniformContinuous.iterate [UniformSpace β] (T : β → β) (n : ℕ) (h : UniformContinuous T) :
    UniformContinuous T^[n] 
goal: UniformContinuous T^[n]

full_name: Filter.HasBasis.uniformContinuous_iff
code: theorem Filter.HasBasis.uniformContinuous_iff {ι'} [UniformSpace β] {p : ι → Prop}
    {s : ι → Set (α × α)} (ha : (𝓤 α).HasBasis p s) {q : ι' → Prop} {t : ι' → Set (β × β)}
    (hb : (𝓤 β).HasBasis q t) {f : α → β} :
    UniformContinuous f ↔ ∀ i, q i → ∃ j, p j ∧ ∀ x y, (x, y) ∈ s j → (f x, f y) ∈ t i 
goal: UniformContinuous f ↔ ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ (x y : α), (x, y) ∈ s j → (f x, f y) ∈ t i

full_name: Filter.HasBasis.uniformContinuousOn_iff
code: theorem Filter.HasBasis.uniformContinuousOn_iff {ι'} [UniformSpace β] {p : ι → Prop}
    {s : ι → Set (α × α)} (ha : (𝓤 α).HasBasis p s) {q : ι' → Prop} {t : ι' → Set (β × β)}
    (hb : (𝓤 β).HasBasis q t) {f : α → β} {S : Set α} :
    UniformContinuousOn f S ↔
      ∀ i, q i → ∃ j, p j ∧ ∀ x, x ∈ S → ∀ y, y ∈ S → (x, y) ∈ s j → (f x, f y) ∈ t i 
goal: UniformContinuousOn f S ↔ ∀ (i : ι'), q i → ∃ j, p j ∧ ∀ x ∈ S, ∀ y ∈ S, (x, y) ∈ s j → (f x, f y) ∈ t i

full_name: instPartialOrderUniformSpace
code: instance : PartialOrder (UniformSpace α) 
goal: PartialOrder (UniformSpace α)

full_name: UniformSpace.le_def
code: protected theorem UniformSpace.le_def {u₁ u₂ : UniformSpace α} : u₁ ≤ u₂ ↔ 𝓤[u₁] ≤ 𝓤[u₂] 
goal: u₁ ≤ u₂ ↔ 𝓤 α ≤ 𝓤 α

full_name: instInfSetUniformSpace
code: instance : InfSet (UniformSpace α) 
goal: InfSet (UniformSpace α)

full_name: UniformSpace.sInf_le
code: protected theorem UniformSpace.sInf_le {tt : Set (UniformSpace α)} {t : UniformSpace α}
    (h : t ∈ tt) : sInf tt ≤ t 
goal: sInf tt ≤ t

full_name: UniformSpace.le_sInf
code: protected theorem UniformSpace.le_sInf {tt : Set (UniformSpace α)} {t : UniformSpace α}
    (h : ∀ t' ∈ tt, t ≤ t') : t ≤ sInf tt 
goal: t ≤ sInf tt

full_name: instTopUniformSpace
code: instance : Top (UniformSpace α) 
goal: Top (UniformSpace α)

full_name: instBotUniformSpace
code: instance : Bot (UniformSpace α) 
goal: Bot (UniformSpace α)

full_name: instInfUniformSpace
code: instance : Inf (UniformSpace α) 
goal: Inf (UniformSpace α)

full_name: instCompleteLatticeUniformSpace
code: instance : CompleteLattice (UniformSpace α) 
goal: CompleteLattice (UniformSpace α)

full_name: iInf_uniformity
code: theorem iInf_uniformity {ι : Sort*} {u : ι → UniformSpace α} : 𝓤[iInf u] = ⨅ i, 𝓤[u i] 
goal: 𝓤 α = ⨅ i, 𝓤 α

full_name: inf_uniformity
code: theorem inf_uniformity {u v : UniformSpace α} : 𝓤[u ⊓ v] = 𝓤[u] ⊓ 𝓤[v] 
goal: 𝓤 α = 𝓤 α ⊓ 𝓤 α

full_name: bot_uniformity
code: lemma bot_uniformity : 𝓤[(⊥ : UniformSpace α)] = 𝓟 idRel 
goal: 𝓤 α = 𝓟 idRel

full_name: top_uniformity
code: lemma top_uniformity : 𝓤[(⊤ : UniformSpace α)] = ⊤ 
goal: 𝓤 α = ⊤

full_name: inhabitedUniformSpace
code: instance inhabitedUniformSpace : Inhabited (UniformSpace α) 
goal: Inhabited (UniformSpace α)

full_name: inhabitedUniformSpaceCore
code: instance inhabitedUniformSpaceCore : Inhabited (UniformSpace.Core α) 
goal: Inhabited (UniformSpace.Core α)

full_name: instUniqueUniformSpaceOfSubsingleton
code: instance [Subsingleton α] : Unique (UniformSpace α) 
goal: Unique (UniformSpace α)

full_name: UniformSpace.comap
code: /-- Given `f : α → β` and a uniformity `u` on `β`, the inverse image of `u` under `f`
  is the inverse image in the filter sense of the induced function `α × α → β × β`.
  See note [reducible non-instances]. -/
abbrev UniformSpace.comap (f : α → β) (u : UniformSpace β) : UniformSpace α 
goal: UniformSpace α

full_name: uniformity_comap
code: theorem uniformity_comap {_ : UniformSpace β} (f : α → β) :
    𝓤[UniformSpace.comap f ‹_›] = comap (Prod.map f f) (𝓤 β) 
goal: ∀ {x : UniformSpace β} (f : α → β), 𝓤 α = Filter.comap (Prod.map f f) (𝓤 β)

full_name: uniformSpace_comap_id
code: @[simp]
theorem uniformSpace_comap_id {α : Type*} : UniformSpace.comap (id : α → α) = id 
goal: UniformSpace.comap id = id

full_name: UniformSpace.comap_comap
code: theorem UniformSpace.comap_comap {α β γ} {uγ : UniformSpace γ} {f : α → β} {g : β → γ} :
    UniformSpace.comap (g ∘ f) uγ = UniformSpace.comap f (UniformSpace.comap g uγ) 
goal: UniformSpace.comap (g ∘ f) uγ = UniformSpace.comap f (UniformSpace.comap g uγ)

full_name: UniformSpace.comap_inf
code: theorem UniformSpace.comap_inf {α γ} {u₁ u₂ : UniformSpace γ} {f : α → γ} :
    (u₁ ⊓ u₂).comap f = u₁.comap f ⊓ u₂.comap f 
goal: UniformSpace.comap f (u₁ ⊓ u₂) = UniformSpace.comap f u₁ ⊓ UniformSpace.comap f u₂

full_name: UniformSpace.comap_iInf
code: theorem UniformSpace.comap_iInf {ι α γ} {u : ι → UniformSpace γ} {f : α → γ} :
    (⨅ i, u i).comap f = ⨅ i, (u i).comap f 
goal: UniformSpace.comap f (⨅ i, u i) = ⨅ i, UniformSpace.comap f (u i)

full_name: UniformSpace.comap_mono
code: theorem UniformSpace.comap_mono {α γ} {f : α → γ} :
    Monotone fun u : UniformSpace γ => u.comap f 
goal: Monotone fun u => UniformSpace.comap f u

full_name: uniformContinuous_iff
code: theorem uniformContinuous_iff {α β} {uα : UniformSpace α} {uβ : UniformSpace β} {f : α → β} :
    UniformContinuous f ↔ uα ≤ uβ.comap f 
goal: UniformContinuous f ↔ uα ≤ UniformSpace.comap f uβ

full_name: le_iff_uniformContinuous_id
code: theorem le_iff_uniformContinuous_id {u v : UniformSpace α} :
    u ≤ v ↔ @UniformContinuous _ _ u v id 
goal: u ≤ v ↔ UniformContinuous id

full_name: uniformContinuous_comap
code: theorem uniformContinuous_comap {f : α → β} [u : UniformSpace β] :
    @UniformContinuous α β (UniformSpace.comap f u) u f 
goal: UniformContinuous f

full_name: uniformContinuous_comap'
code: theorem uniformContinuous_comap' {f : γ → β} {g : α → γ} [v : UniformSpace β] [u : UniformSpace α]
    (h : UniformContinuous (f ∘ g)) : @UniformContinuous α γ u (UniformSpace.comap f v) g 
goal: UniformContinuous g

full_name: UniformSpace.to_nhds_mono
code: theorem to_nhds_mono {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂) (a : α) :
    @nhds _ (@UniformSpace.toTopologicalSpace _ u₁) a ≤
      @nhds _ (@UniformSpace.toTopologicalSpace _ u₂) a 
goal: 𝓝 a ≤ 𝓝 a

full_name: UniformSpace.toTopologicalSpace_mono
code: theorem toTopologicalSpace_mono {u₁ u₂ : UniformSpace α} (h : u₁ ≤ u₂) :
    @UniformSpace.toTopologicalSpace _ u₁ ≤ @UniformSpace.toTopologicalSpace _ u₂ 
goal: UniformSpace.toTopologicalSpace ≤ UniformSpace.toTopologicalSpace

full_name: UniformSpace.toTopologicalSpace_comap
code: theorem toTopologicalSpace_comap {f : α → β} {u : UniformSpace β} :
    @UniformSpace.toTopologicalSpace _ (UniformSpace.comap f u) =
      TopologicalSpace.induced f (@UniformSpace.toTopologicalSpace β u) 
goal: UniformSpace.toTopologicalSpace = TopologicalSpace.induced f UniformSpace.toTopologicalSpace

full_name: UniformSpace.uniformSpace_eq_bot
code: lemma uniformSpace_eq_bot {u : UniformSpace α} : u = ⊥ ↔ idRel ∈ 𝓤[u] 
goal: u = ⊥ ↔ idRel ∈ 𝓤 α

full_name: Filter.HasBasis.uniformSpace_eq_bot
code: protected lemma _root_.Filter.HasBasis.uniformSpace_eq_bot {ι p} {s : ι → Set (α × α)}
    {u : UniformSpace α} (h : 𝓤[u].HasBasis p s) :
    u = ⊥ ↔ ∃ i, p i ∧ Pairwise fun x y : α ↦ (x, y) ∉ s i 
goal: u = ⊥ ↔ ∃ i, p i ∧ Pairwise fun x y => (x, y) ∉ s i

full_name: UniformSpace.toTopologicalSpace_bot
code: theorem toTopologicalSpace_bot : @UniformSpace.toTopologicalSpace α ⊥ = ⊥ 
goal: UniformSpace.toTopologicalSpace = ⊥

full_name: UniformSpace.toTopologicalSpace_top
code: theorem toTopologicalSpace_top : @UniformSpace.toTopologicalSpace α ⊤ = ⊤ 
goal: UniformSpace.toTopologicalSpace = ⊤

full_name: UniformSpace.toTopologicalSpace_iInf
code: theorem toTopologicalSpace_iInf {ι : Sort*} {u : ι → UniformSpace α} :
    (iInf u).toTopologicalSpace = ⨅ i, (u i).toTopologicalSpace 
goal: UniformSpace.toTopologicalSpace = ⨅ i, UniformSpace.toTopologicalSpace

full_name: UniformSpace.toTopologicalSpace_sInf
code: theorem toTopologicalSpace_sInf {s : Set (UniformSpace α)} :
    (sInf s).toTopologicalSpace = ⨅ i ∈ s, @UniformSpace.toTopologicalSpace α i 
goal: UniformSpace.toTopologicalSpace = ⨅ i ∈ s, UniformSpace.toTopologicalSpace

full_name: UniformSpace.toTopologicalSpace_inf
code: theorem toTopologicalSpace_inf {u v : UniformSpace α} :
    (u ⊓ v).toTopologicalSpace = u.toTopologicalSpace ⊓ v.toTopologicalSpace 
goal: UniformSpace.toTopologicalSpace = UniformSpace.toTopologicalSpace ⊓ UniformSpace.toTopologicalSpace

full_name: UniformContinuous.continuous
code: theorem UniformContinuous.continuous [UniformSpace α] [UniformSpace β] {f : α → β}
    (hf : UniformContinuous f) : Continuous f 
goal: Continuous f

full_name: ULift.uniformSpace
code: /-- Uniform space structure on `ULift α`. -/
instance ULift.uniformSpace [UniformSpace α] : UniformSpace (ULift α) 
goal: UniformSpace (ULift.{u_2, ua} α)

full_name: UniformContinuous.inf_rng
code: theorem UniformContinuous.inf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ u₃ : UniformSpace β}
    (h₁ : UniformContinuous[u₁, u₂] f) (h₂ : UniformContinuous[u₁, u₃] f) :
    UniformContinuous[u₁, u₂ ⊓ u₃] f 
goal: UniformContinuous f

full_name: UniformContinuous.inf_dom_left
code: theorem UniformContinuous.inf_dom_left {f : α → β} {u₁ u₂ : UniformSpace α} {u₃ : UniformSpace β}
    (hf : UniformContinuous[u₁, u₃] f) : UniformContinuous[u₁ ⊓ u₂, u₃] f 
goal: UniformContinuous f

full_name: UniformContinuous.inf_dom_right
code: theorem UniformContinuous.inf_dom_right {f : α → β} {u₁ u₂ : UniformSpace α} {u₃ : UniformSpace β}
    (hf : UniformContinuous[u₂, u₃] f) : UniformContinuous[u₁ ⊓ u₂, u₃] f 
goal: UniformContinuous f

full_name: uniformContinuous_sInf_dom
code: theorem uniformContinuous_sInf_dom {f : α → β} {u₁ : Set (UniformSpace α)} {u₂ : UniformSpace β}
    {u : UniformSpace α} (h₁ : u ∈ u₁) (hf : UniformContinuous[u, u₂] f) :
    UniformContinuous[sInf u₁, u₂] f 
goal: UniformContinuous f

full_name: uniformContinuous_sInf_rng
code: theorem uniformContinuous_sInf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ : Set (UniformSpace β)} :
    UniformContinuous[u₁, sInf u₂] f ↔ ∀ u ∈ u₂, UniformContinuous[u₁, u] f 
goal: UniformContinuous f ↔ ∀ u ∈ u₂, UniformContinuous f

full_name: uniformContinuous_iInf_dom
code: theorem uniformContinuous_iInf_dom {f : α → β} {u₁ : ι → UniformSpace α} {u₂ : UniformSpace β}
    {i : ι} (hf : UniformContinuous[u₁ i, u₂] f) : UniformContinuous[iInf u₁, u₂] f 
goal: UniformContinuous f

full_name: uniformContinuous_iInf_rng
code: theorem uniformContinuous_iInf_rng {f : α → β} {u₁ : UniformSpace α} {u₂ : ι → UniformSpace β} :
    UniformContinuous[u₁, iInf u₂] f ↔ ∀ i, UniformContinuous[u₁, u₂ i] f 
goal: UniformContinuous f ↔ ∀ (i : ι), UniformContinuous f

full_name: discreteTopology_of_discrete_uniformity
code: /-- A uniform space with the discrete uniformity has the discrete topology. -/
theorem discreteTopology_of_discrete_uniformity [hα : UniformSpace α] (h : uniformity α = 𝓟 idRel) :
    DiscreteTopology α 
goal: DiscreteTopology α

full_name: instUniformSpaceEmpty
code: instance : UniformSpace Empty 
goal: UniformSpace Empty

full_name: instUniformSpacePUnit
code: instance : UniformSpace PUnit 
goal: UniformSpace PUnit.{u_2 + 1}

full_name: instUniformSpaceBool
code: instance : UniformSpace Bool 
goal: UniformSpace Bool

full_name: instUniformSpaceNat
code: instance : UniformSpace ℕ 
goal: UniformSpace ℕ

full_name: instUniformSpaceInt
code: instance : UniformSpace ℤ 
goal: UniformSpace ℤ

full_name: instUniformSpaceAdditive
code: instance : UniformSpace (Additive α) 
goal: UniformSpace (Additive α)

full_name: instUniformSpaceMultiplicative
code: instance : UniformSpace (Multiplicative α) 
goal: UniformSpace (Multiplicative α)

full_name: uniformContinuous_ofMul
code: theorem uniformContinuous_ofMul : UniformContinuous (ofMul : α → Additive α) 
goal: UniformContinuous ⇑Additive.ofMul

full_name: uniformContinuous_toMul
code: theorem uniformContinuous_toMul : UniformContinuous (toMul : Additive α → α) 
goal: UniformContinuous ⇑Additive.toMul

full_name: uniformContinuous_ofAdd
code: theorem uniformContinuous_ofAdd : UniformContinuous (ofAdd : α → Multiplicative α) 
goal: UniformContinuous ⇑Multiplicative.ofAdd

full_name: uniformContinuous_toAdd
code: theorem uniformContinuous_toAdd : UniformContinuous (toAdd : Multiplicative α → α) 
goal: UniformContinuous ⇑Multiplicative.toAdd

full_name: uniformity_additive
code: theorem uniformity_additive : 𝓤 (Additive α) = (𝓤 α).map (Prod.map ofMul ofMul) 
goal: 𝓤 (Additive α) = Filter.map (Prod.map ⇑Additive.ofMul ⇑Additive.ofMul) (𝓤 α)

full_name: uniformity_multiplicative
code: theorem uniformity_multiplicative : 𝓤 (Multiplicative α) = (𝓤 α).map (Prod.map ofAdd ofAdd) 
goal: 𝓤 (Multiplicative α) = Filter.map (Prod.map ⇑Multiplicative.ofAdd ⇑Multiplicative.ofAdd) (𝓤 α)

full_name: instUniformSpaceSubtype
code: instance instUniformSpaceSubtype {p : α → Prop} [t : UniformSpace α] : UniformSpace (Subtype p) 
goal: UniformSpace (Subtype p)

full_name: uniformity_subtype
code: theorem uniformity_subtype {p : α → Prop} [UniformSpace α] :
    𝓤 (Subtype p) = comap (fun q : Subtype p × Subtype p => (q.1.1, q.2.1)) (𝓤 α) 
goal: 𝓤 (Subtype p) = Filter.comap (fun q => (↑q.1, ↑q.2)) (𝓤 α)

full_name: uniformity_setCoe
code: theorem uniformity_setCoe {s : Set α} [UniformSpace α] :
    𝓤 s = comap (Prod.map ((↑) : s → α) ((↑) : s → α)) (𝓤 α) 
goal: 𝓤 ↑s = Filter.comap (Prod.map Subtype.val Subtype.val) (𝓤 α)

full_name: map_uniformity_set_coe
code: theorem map_uniformity_set_coe {s : Set α} [UniformSpace α] :
    map (Prod.map (↑) (↑)) (𝓤 s) = 𝓤 α ⊓ 𝓟 (s ×ˢ s) 
goal: Filter.map (Prod.map Subtype.val Subtype.val) (𝓤 ↑s) = 𝓤 α ⊓ 𝓟 (s ×ˢ s)

full_name: uniformContinuous_subtype_val
code: theorem uniformContinuous_subtype_val {p : α → Prop} [UniformSpace α] :
    UniformContinuous (Subtype.val : { a : α // p a } → α) 
goal: UniformContinuous Subtype.val

full_name: UniformContinuous.subtype_mk
code: theorem UniformContinuous.subtype_mk {p : α → Prop} [UniformSpace α] [UniformSpace β] {f : β → α}
    (hf : UniformContinuous f) (h : ∀ x, p (f x)) :
    UniformContinuous (fun x => ⟨f x, h x⟩ : β → Subtype p) 
goal: UniformContinuous fun x => ⟨f x, ⋯⟩

full_name: uniformContinuousOn_iff_restrict
code: theorem uniformContinuousOn_iff_restrict [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α} :
    UniformContinuousOn f s ↔ UniformContinuous (s.restrict f) 
goal: UniformContinuousOn f s ↔ UniformContinuous (s.restrict f)

full_name: tendsto_of_uniformContinuous_subtype
code: theorem tendsto_of_uniformContinuous_subtype [UniformSpace α] [UniformSpace β] {f : α → β}
    {s : Set α} {a : α} (hf : UniformContinuous fun x : s => f x.val) (ha : s ∈ 𝓝 a) :
    Tendsto f (𝓝 a) (𝓝 (f a)) 
goal: Filter.Tendsto f (𝓝 a) (𝓝 (f a))

full_name: UniformContinuousOn.continuousOn
code: theorem UniformContinuousOn.continuousOn [UniformSpace α] [UniformSpace β] {f : α → β} {s : Set α}
    (h : UniformContinuousOn f s) : ContinuousOn f s 
goal: ContinuousOn f s

full_name: instUniformSpaceAddOpposite
code: @[to_additive]
instance [UniformSpace α] : UniformSpace αᵐᵒᵖ 
goal: UniformSpace αᵃᵒᵖ

full_name: instUniformSpaceMulOpposite
code: @[to_additive]
instance [UniformSpace α] : UniformSpace αᵐᵒᵖ 
goal: UniformSpace αᵐᵒᵖ

full_name: uniformity_addOpposite
code: @[to_additive]
theorem uniformity_mulOpposite [UniformSpace α] :
    𝓤 αᵐᵒᵖ = comap (fun q : αᵐᵒᵖ × αᵐᵒᵖ => (q.1.unop, q.2.unop)) (𝓤 α) 
goal: 𝓤 αᵃᵒᵖ = Filter.comap (fun q => (AddOpposite.unop q.1, AddOpposite.unop q.2)) (𝓤 α)

full_name: uniformity_mulOpposite
code: @[to_additive]
theorem uniformity_mulOpposite [UniformSpace α] :
    𝓤 αᵐᵒᵖ = comap (fun q : αᵐᵒᵖ × αᵐᵒᵖ => (q.1.unop, q.2.unop)) (𝓤 α) 
goal: 𝓤 αᵐᵒᵖ = Filter.comap (fun q => (MulOpposite.unop q.1, MulOpposite.unop q.2)) (𝓤 α)

full_name: comap_uniformity_addOpposite
code: @[to_additive (attr := simp)]
theorem comap_uniformity_mulOpposite [UniformSpace α] :
    comap (fun p : α × α => (MulOpposite.op p.1, MulOpposite.op p.2)) (𝓤 αᵐᵒᵖ) = 𝓤 α 
goal: Filter.comap (fun p => (AddOpposite.op p.1, AddOpposite.op p.2)) (𝓤 αᵃᵒᵖ) = 𝓤 α

full_name: comap_uniformity_mulOpposite
code: @[to_additive (attr := simp)]
theorem comap_uniformity_mulOpposite [UniformSpace α] :
    comap (fun p : α × α => (MulOpposite.op p.1, MulOpposite.op p.2)) (𝓤 αᵐᵒᵖ) = 𝓤 α 
goal: Filter.comap (fun p => (MulOpposite.op p.1, MulOpposite.op p.2)) (𝓤 αᵐᵒᵖ) = 𝓤 α

full_name: MulOpposite.uniformContinuous_unop
code: @[to_additive]
theorem uniformContinuous_unop [UniformSpace α] : UniformContinuous (unop : αᵐᵒᵖ → α) 
goal: UniformContinuous MulOpposite.unop

full_name: AddOpposite.uniformContinuous_unop
code: @[to_additive]
theorem uniformContinuous_unop [UniformSpace α] : UniformContinuous (unop : αᵐᵒᵖ → α) 
goal: UniformContinuous AddOpposite.unop

full_name: MulOpposite.uniformContinuous_op
code: @[to_additive]
theorem uniformContinuous_op [UniformSpace α] : UniformContinuous (op : α → αᵐᵒᵖ) 
goal: UniformContinuous MulOpposite.op

full_name: AddOpposite.uniformContinuous_op
code: @[to_additive]
theorem uniformContinuous_op [UniformSpace α] : UniformContinuous (op : α → αᵐᵒᵖ) 
goal: UniformContinuous AddOpposite.op

full_name: instUniformSpaceProd
code: instance instUniformSpaceProd [u₁ : UniformSpace α] [u₂ : UniformSpace β] : UniformSpace (α × β) 
goal: UniformSpace (α × β)

full_name: uniformity_prod
code: theorem uniformity_prod [UniformSpace α] [UniformSpace β] :
    𝓤 (α × β) =
      ((𝓤 α).comap fun p : (α × β) × α × β => (p.1.1, p.2.1)) ⊓
        (𝓤 β).comap fun p : (α × β) × α × β => (p.1.2, p.2.2) 
goal: 𝓤 (α × β) = Filter.comap (fun p => (p.1.1, p.2.1)) (𝓤 α) ⊓ Filter.comap (fun p => (p.1.2, p.2.2)) (𝓤 β)

full_name: instIsCountablyGeneratedProdUniformity
code: instance [UniformSpace α] [IsCountablyGenerated (𝓤 α)]
    [UniformSpace β] [IsCountablyGenerated (𝓤 β)] : IsCountablyGenerated (𝓤 (α × β)) 
goal: (𝓤 (α × β)).IsCountablyGenerated

full_name: uniformity_prod_eq_comap_prod
code: theorem uniformity_prod_eq_comap_prod [UniformSpace α] [UniformSpace β] :
    𝓤 (α × β) =
      comap (fun p : (α × β) × α × β => ((p.1.1, p.2.1), (p.1.2, p.2.2))) (𝓤 α ×ˢ 𝓤 β) 
goal: 𝓤 (α × β) = Filter.comap (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 β)

full_name: uniformity_prod_eq_prod
code: theorem uniformity_prod_eq_prod [UniformSpace α] [UniformSpace β] :
    𝓤 (α × β) = map (fun p : (α × α) × β × β => ((p.1.1, p.2.1), (p.1.2, p.2.2))) (𝓤 α ×ˢ 𝓤 β) 
goal: 𝓤 (α × β) = Filter.map (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 β)

full_name: mem_uniformity_of_uniformContinuous_invariant
code: theorem mem_uniformity_of_uniformContinuous_invariant [UniformSpace α] [UniformSpace β]
    {s : Set (β × β)} {f : α → α → β} (hf : UniformContinuous fun p : α × α => f p.1 p.2)
    (hs : s ∈ 𝓤 β) : ∃ u ∈ 𝓤 α, ∀ a b c, (a, b) ∈ u → (f a c, f b c) ∈ s 
goal: ∃ u ∈ 𝓤 α, ∀ (a b c : α), (a, b) ∈ u → (f a c, f b c) ∈ s

full_name: mem_uniform_prod
code: theorem mem_uniform_prod [t₁ : UniformSpace α] [t₂ : UniformSpace β] {a : Set (α × α)}
    {b : Set (β × β)} (ha : a ∈ 𝓤 α) (hb : b ∈ 𝓤 β) :
    { p : (α × β) × α × β | (p.1.1, p.2.1) ∈ a ∧ (p.1.2, p.2.2) ∈ b } ∈ 𝓤 (α × β) 
goal: {p | (p.1.1, p.2.1) ∈ a ∧ (p.1.2, p.2.2) ∈ b} ∈ 𝓤 (α × β)

full_name: tendsto_prod_uniformity_fst
code: theorem tendsto_prod_uniformity_fst [UniformSpace α] [UniformSpace β] :
    Tendsto (fun p : (α × β) × α × β => (p.1.1, p.2.1)) (𝓤 (α × β)) (𝓤 α) 
goal: Filter.Tendsto (fun p => (p.1.1, p.2.1)) (𝓤 (α × β)) (𝓤 α)

full_name: tendsto_prod_uniformity_snd
code: theorem tendsto_prod_uniformity_snd [UniformSpace α] [UniformSpace β] :
    Tendsto (fun p : (α × β) × α × β => (p.1.2, p.2.2)) (𝓤 (α × β)) (𝓤 β) 
goal: Filter.Tendsto (fun p => (p.1.2, p.2.2)) (𝓤 (α × β)) (𝓤 β)

full_name: uniformContinuous_fst
code: theorem uniformContinuous_fst [UniformSpace α] [UniformSpace β] :
    UniformContinuous fun p : α × β => p.1 
goal: UniformContinuous fun p => p.1

full_name: uniformContinuous_snd
code: theorem uniformContinuous_snd [UniformSpace α] [UniformSpace β] :
    UniformContinuous fun p : α × β => p.2 
goal: UniformContinuous fun p => p.2

full_name: UniformContinuous.prod_mk
code: theorem UniformContinuous.prod_mk {f₁ : α → β} {f₂ : α → γ} (h₁ : UniformContinuous f₁)
    (h₂ : UniformContinuous f₂) : UniformContinuous fun a => (f₁ a, f₂ a) 
goal: UniformContinuous fun a => (f₁ a, f₂ a)

full_name: UniformContinuous.prod_mk_left
code: theorem UniformContinuous.prod_mk_left {f : α × β → γ} (h : UniformContinuous f) (b) :
    UniformContinuous fun a => f (a, b) 
goal: UniformContinuous fun a => f (a, b)

full_name: UniformContinuous.prod_mk_right
code: theorem UniformContinuous.prod_mk_right {f : α × β → γ} (h : UniformContinuous f) (a) :
    UniformContinuous fun b => f (a, b) 
goal: UniformContinuous fun b => f (a, b)

full_name: UniformContinuous.prod_map
code: theorem UniformContinuous.prod_map [UniformSpace δ] {f : α → γ} {g : β → δ}
    (hf : UniformContinuous f) (hg : UniformContinuous g) : UniformContinuous (Prod.map f g) 
goal: UniformContinuous (Prod.map f g)

full_name: toTopologicalSpace_prod
code: theorem toTopologicalSpace_prod {α} {β} [u : UniformSpace α] [v : UniformSpace β] :
    @UniformSpace.toTopologicalSpace (α × β) instUniformSpaceProd =
      @instTopologicalSpaceProd α β u.toTopologicalSpace v.toTopologicalSpace 
goal: UniformSpace.toTopologicalSpace = instTopologicalSpaceProd

full_name: uniformContinuous_inf_dom_left₂
code: /-- A version of `UniformContinuous.inf_dom_left` for binary functions -/
theorem uniformContinuous_inf_dom_left₂ {α β γ} {f : α → β → γ} {ua1 ua2 : UniformSpace α}
    {ub1 ub2 : UniformSpace β} {uc1 : UniformSpace γ}
    (h : by haveI := ua1; haveI := ub1; exact UniformContinuous fun p : α × β => f p.1 p.2) : by
      haveI := ua1 ⊓ ua2; haveI := ub1 ⊓ ub2
      exact UniformContinuous fun p : α × β => f p.1 p.2 
goal: UniformContinuous fun p => f p.1 p.2

full_name: uniformContinuous_inf_dom_right₂
code: /-- A version of `UniformContinuous.inf_dom_right` for binary functions -/
theorem uniformContinuous_inf_dom_right₂ {α β γ} {f : α → β → γ} {ua1 ua2 : UniformSpace α}
    {ub1 ub2 : UniformSpace β} {uc1 : UniformSpace γ}
    (h : by haveI := ua2; haveI := ub2; exact UniformContinuous fun p : α × β => f p.1 p.2) : by
      haveI := ua1 ⊓ ua2; haveI := ub1 ⊓ ub2
      exact UniformContinuous fun p : α × β => f p.1 p.2 
goal: UniformContinuous fun p => f p.1 p.2

full_name: uniformContinuous_sInf_dom₂
code: /-- A version of `uniformContinuous_sInf_dom` for binary functions -/
theorem uniformContinuous_sInf_dom₂ {α β γ} {f : α → β → γ} {uas : Set (UniformSpace α)}
    {ubs : Set (UniformSpace β)} {ua : UniformSpace α} {ub : UniformSpace β} {uc : UniformSpace γ}
    (ha : ua ∈ uas) (hb : ub ∈ ubs) (hf : UniformContinuous fun p : α × β => f p.1 p.2) : by
      haveI := sInf uas; haveI := sInf ubs
      exact @UniformContinuous _ _ _ uc fun p : α × β => f p.1 p.2 
goal: UniformContinuous fun p => f p.1 p.2

full_name: _aux_Mathlib_Topology_UniformSpace_Basic___unexpand_Function_bicompr_1
code: local notation f " ∘₂ " g => Function.bicompr f g
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Topology_UniformSpace_Basic___macroRules_term_∘₂__1»
code: local notation f " ∘₂ " g => Function.bicompr f g
goal: Lean.Macro

full_name: UniformContinuous₂
code: /-- Uniform continuity for functions of two variables. -/
def UniformContinuous₂ (f : α → β → γ) 
goal: Prop

full_name: uniformContinuous₂_def
code: theorem uniformContinuous₂_def (f : α → β → γ) :
    UniformContinuous₂ f ↔ UniformContinuous (uncurry f) 
goal: UniformContinuous₂ f ↔ UniformContinuous (Function.uncurry f)

full_name: UniformContinuous₂.uniformContinuous
code: theorem UniformContinuous₂.uniformContinuous {f : α → β → γ} (h : UniformContinuous₂ f) :
    UniformContinuous (uncurry f) 
goal: UniformContinuous (Function.uncurry f)

full_name: uniformContinuous₂_curry
code: theorem uniformContinuous₂_curry (f : α × β → γ) :
    UniformContinuous₂ (Function.curry f) ↔ UniformContinuous f 
goal: UniformContinuous₂ (Function.curry f) ↔ UniformContinuous f

full_name: UniformContinuous₂.comp
code: theorem UniformContinuous₂.comp {f : α → β → γ} {g : γ → δ} (hg : UniformContinuous g)
    (hf : UniformContinuous₂ f) : UniformContinuous₂ (g ∘₂ f) 
goal: UniformContinuous₂ (Function.bicompr g f)

full_name: UniformContinuous₂.bicompl
code: theorem UniformContinuous₂.bicompl {f : α → β → γ} {ga : δ → α} {gb : δ' → β}
    (hf : UniformContinuous₂ f) (hga : UniformContinuous ga) (hgb : UniformContinuous gb) :
    UniformContinuous₂ (bicompl f ga gb) 
goal: UniformContinuous₂ (Function.bicompl f ga gb)

full_name: toTopologicalSpace_subtype
code: theorem toTopologicalSpace_subtype [u : UniformSpace α] {p : α → Prop} :
    @UniformSpace.toTopologicalSpace (Subtype p) instUniformSpaceSubtype =
      @instTopologicalSpaceSubtype α p u.toTopologicalSpace 
goal: UniformSpace.toTopologicalSpace = instTopologicalSpaceSubtype

full_name: Sum.instUniformSpace
code: /-- Uniformity on a disjoint union. Entourages of the diagonal in the union are obtained
by taking independently an entourage of the diagonal in the first part, and an entourage of
the diagonal in the second part. -/
instance Sum.instUniformSpace : UniformSpace (α ⊕ β) 
goal: UniformSpace (α ⊕ β)

full_name: union_mem_uniformity_sum
code: /-- The union of an entourage of the diagonal in each set of a disjoint union is again an entourage
of the diagonal. -/
theorem union_mem_uniformity_sum {a : Set (α × α)} (ha : a ∈ 𝓤 α) {b : Set (β × β)} (hb : b ∈ 𝓤 β) :
    Prod.map inl inl '' a ∪ Prod.map inr inr '' b ∈ 𝓤 (α ⊕ β) 
goal: Prod.map Sum.inl Sum.inl '' a ∪ Prod.map Sum.inr Sum.inr '' b ∈ 𝓤 (α ⊕ β)

full_name: Sum.uniformity
code: theorem Sum.uniformity : 𝓤 (α ⊕ β) = map (Prod.map inl inl) (𝓤 α) ⊔ map (Prod.map inr inr) (𝓤 β) 
goal: 𝓤 (α ⊕ β) = Filter.map (Prod.map Sum.inl Sum.inl) (𝓤 α) ⊔ Filter.map (Prod.map Sum.inr Sum.inr) (𝓤 β)

full_name: uniformContinuous_inl
code: lemma uniformContinuous_inl : UniformContinuous (Sum.inl : α → α ⊕ β) 
goal: UniformContinuous Sum.inl

full_name: uniformContinuous_inr
code: lemma uniformContinuous_inr : UniformContinuous (Sum.inr : β → α ⊕ β) 
goal: UniformContinuous Sum.inr

full_name: instIsCountablyGeneratedProdSumUniformity
code: instance [IsCountablyGenerated (𝓤 α)] [IsCountablyGenerated (𝓤 β)] :
    IsCountablyGenerated (𝓤 (α ⊕ β)) 
goal: (𝓤 (α ⊕ β)).IsCountablyGenerated

full_name: lebesgue_number_lemma
code: /-- Let `c : ι → Set α` be an open cover of a compact set `s`. Then there exists an entourage
`n` such that for each `x ∈ s` its `n`-neighborhood is contained in some `c i`. -/
theorem lebesgue_number_lemma {ι : Sort*} {U : ι → Set α} (hK : IsCompact K)
    (hopen : ∀ i, IsOpen (U i)) (hcover : K ⊆ ⋃ i, U i) :
    ∃ V ∈ 𝓤 α, ∀ x ∈ K, ∃ i, ball x V ⊆ U i 
goal: ∃ V ∈ 𝓤 α, ∀ x ∈ K, ∃ i, UniformSpace.ball x V ⊆ U i

full_name: Filter.HasBasis.lebesgue_number_lemma
code: /-- Let `U : ι → Set α` be an open cover of a compact set `K`.
Then there exists an entourage `V`
such that for each `x ∈ K` its `V`-neighborhood is included in some `U i`.

Moreover, one can choose an entourage from a given basis. -/
protected theorem Filter.HasBasis.lebesgue_number_lemma {ι' ι : Sort*} {p : ι' → Prop}
    {V : ι' → Set (α × α)} {U : ι → Set α} (hbasis : (𝓤 α).HasBasis p V) (hK : IsCompact K)
    (hopen : ∀ j, IsOpen (U j)) (hcover : K ⊆ ⋃ j, U j) :
    ∃ i, p i ∧ ∀ x ∈ K, ∃ j, ball x (V i) ⊆ U j 
goal: ∃ i, p i ∧ ∀ x ∈ K, ∃ j, UniformSpace.ball x (V i) ⊆ U j

full_name: lebesgue_number_lemma_sUnion
code: /-- Let `c : Set (Set α)` be an open cover of a compact set `s`. Then there exists an entourage
`n` such that for each `x ∈ s` its `n`-neighborhood is contained in some `t ∈ c`. -/
theorem lebesgue_number_lemma_sUnion {S : Set (Set α)}
    (hK : IsCompact K) (hopen : ∀ s ∈ S, IsOpen s) (hcover : K ⊆ ⋃₀ S) :
    ∃ V ∈ 𝓤 α, ∀ x ∈ K, ∃ s ∈ S, ball x V ⊆ s 
goal: ∃ V ∈ 𝓤 α, ∀ x ∈ K, ∃ s ∈ S, UniformSpace.ball x V ⊆ s

full_name: IsCompact.nhdsSet_basis_uniformity
code: /-- If `K` is a compact set in a uniform space and `{V i | p i}` is a basis of entourages,
then `{⋃ x ∈ K, UniformSpace.ball x (V i) | p i}` is a basis of `𝓝ˢ K`.

Here "`{s i | p i}` is a basis of a filter `l`" means `Filter.HasBasis l p s`. -/
theorem IsCompact.nhdsSet_basis_uniformity {p : ι → Prop} {V : ι → Set (α × α)}
    (hbasis : (𝓤 α).HasBasis p V) (hK : IsCompact K) :
    (𝓝ˢ K).HasBasis p fun i => ⋃ x ∈ K, ball x (V i) 
goal: (𝓝ˢ K).HasBasis p fun i => ⋃ x ∈ K, UniformSpace.ball x (V i)

full_name: Disjoint.exists_uniform_thickening
code: theorem Disjoint.exists_uniform_thickening {A B : Set α} (hA : IsCompact A) (hB : IsClosed B)
    (h : Disjoint A B) : ∃ V ∈ 𝓤 α, Disjoint (⋃ x ∈ A, ball x V) (⋃ x ∈ B, ball x V) 
goal: ∃ V ∈ 𝓤 α, Disjoint (⋃ x ∈ A, UniformSpace.ball x V) (⋃ x ∈ B, UniformSpace.ball x V)

full_name: Disjoint.exists_uniform_thickening_of_basis
code: theorem Disjoint.exists_uniform_thickening_of_basis {p : ι → Prop} {s : ι → Set (α × α)}
    (hU : (𝓤 α).HasBasis p s) {A B : Set α} (hA : IsCompact A) (hB : IsClosed B)
    (h : Disjoint A B) : ∃ i, p i ∧ Disjoint (⋃ x ∈ A, ball x (s i)) (⋃ x ∈ B, ball x (s i)) 
goal: ∃ i, p i ∧ Disjoint (⋃ x ∈ A, UniformSpace.ball x (s i)) (⋃ x ∈ B, UniformSpace.ball x (s i))

full_name: lebesgue_number_of_compact_open
code: /-- A useful consequence of the Lebesgue number lemma: given any compact set `K` contained in an
open set `U`, we can find an (open) entourage `V` such that the ball of size `V` about any point of
`K` is contained in `U`. -/
theorem lebesgue_number_of_compact_open {K U : Set α} (hK : IsCompact K)
    (hU : IsOpen U) (hKU : K ⊆ U) : ∃ V ∈ 𝓤 α, IsOpen V ∧ ∀ x ∈ K, UniformSpace.ball x V ⊆ U 
goal: ∃ V ∈ 𝓤 α, IsOpen V ∧ ∀ x ∈ K, UniformSpace.ball x V ⊆ U

full_name: Uniform.tendsto_nhds_right
code: theorem tendsto_nhds_right {f : Filter β} {u : β → α} {a : α} :
    Tendsto u f (𝓝 a) ↔ Tendsto (fun x => (a, u x)) f (𝓤 α) 
goal: Filter.Tendsto u f (𝓝 a) ↔ Filter.Tendsto (fun x => (a, u x)) f (𝓤 α)

full_name: Uniform.tendsto_nhds_left
code: theorem tendsto_nhds_left {f : Filter β} {u : β → α} {a : α} :
    Tendsto u f (𝓝 a) ↔ Tendsto (fun x => (u x, a)) f (𝓤 α) 
goal: Filter.Tendsto u f (𝓝 a) ↔ Filter.Tendsto (fun x => (u x, a)) f (𝓤 α)

full_name: Uniform.continuousAt_iff'_right
code: theorem continuousAt_iff'_right [TopologicalSpace β] {f : β → α} {b : β} :
    ContinuousAt f b ↔ Tendsto (fun x => (f b, f x)) (𝓝 b) (𝓤 α) 
goal: ContinuousAt f b ↔ Filter.Tendsto (fun x => (f b, f x)) (𝓝 b) (𝓤 α)

full_name: Uniform.continuousAt_iff'_left
code: theorem continuousAt_iff'_left [TopologicalSpace β] {f : β → α} {b : β} :
    ContinuousAt f b ↔ Tendsto (fun x => (f x, f b)) (𝓝 b) (𝓤 α) 
goal: ContinuousAt f b ↔ Filter.Tendsto (fun x => (f x, f b)) (𝓝 b) (𝓤 α)

full_name: Uniform.continuousAt_iff_prod
code: theorem continuousAt_iff_prod [TopologicalSpace β] {f : β → α} {b : β} :
    ContinuousAt f b ↔ Tendsto (fun x : β × β => (f x.1, f x.2)) (𝓝 (b, b)) (𝓤 α) 
goal: ContinuousAt f b ↔ Filter.Tendsto (fun x => (f x.1, f x.2)) (𝓝 (b, b)) (𝓤 α)

full_name: Uniform.continuousWithinAt_iff'_right
code: theorem continuousWithinAt_iff'_right [TopologicalSpace β] {f : β → α} {b : β} {s : Set β} :
    ContinuousWithinAt f s b ↔ Tendsto (fun x => (f b, f x)) (𝓝[s] b) (𝓤 α) 
goal: ContinuousWithinAt f s b ↔ Filter.Tendsto (fun x => (f b, f x)) (𝓝[s] b) (𝓤 α)

full_name: Uniform.continuousWithinAt_iff'_left
code: theorem continuousWithinAt_iff'_left [TopologicalSpace β] {f : β → α} {b : β} {s : Set β} :
    ContinuousWithinAt f s b ↔ Tendsto (fun x => (f x, f b)) (𝓝[s] b) (𝓤 α) 
goal: ContinuousWithinAt f s b ↔ Filter.Tendsto (fun x => (f x, f b)) (𝓝[s] b) (𝓤 α)

full_name: Uniform.continuousOn_iff'_right
code: theorem continuousOn_iff'_right [TopologicalSpace β] {f : β → α} {s : Set β} :
    ContinuousOn f s ↔ ∀ b ∈ s, Tendsto (fun x => (f b, f x)) (𝓝[s] b) (𝓤 α) 
goal: ContinuousOn f s ↔ ∀ b ∈ s, Filter.Tendsto (fun x => (f b, f x)) (𝓝[s] b) (𝓤 α)

full_name: Uniform.continuousOn_iff'_left
code: theorem continuousOn_iff'_left [TopologicalSpace β] {f : β → α} {s : Set β} :
    ContinuousOn f s ↔ ∀ b ∈ s, Tendsto (fun x => (f x, f b)) (𝓝[s] b) (𝓤 α) 
goal: ContinuousOn f s ↔ ∀ b ∈ s, Filter.Tendsto (fun x => (f x, f b)) (𝓝[s] b) (𝓤 α)

full_name: Uniform.continuous_iff'_right
code: theorem continuous_iff'_right [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ ∀ b, Tendsto (fun x => (f b, f x)) (𝓝 b) (𝓤 α) 
goal: Continuous f ↔ ∀ (b : β), Filter.Tendsto (fun x => (f b, f x)) (𝓝 b) (𝓤 α)

full_name: Uniform.continuous_iff'_left
code: theorem continuous_iff'_left [TopologicalSpace β] {f : β → α} :
    Continuous f ↔ ∀ b, Tendsto (fun x => (f x, f b)) (𝓝 b) (𝓤 α) 
goal: Continuous f ↔ ∀ (b : β), Filter.Tendsto (fun x => (f x, f b)) (𝓝 b) (𝓤 α)

full_name: Uniform.exists_is_open_mem_uniformity_of_forall_mem_eq
code: /-- Consider two functions `f` and `g` which coincide on a set `s` and are continuous there.
Then there is an open neighborhood of `s` on which `f` and `g` are uniformly close. -/
lemma exists_is_open_mem_uniformity_of_forall_mem_eq
    [TopologicalSpace β] {r : Set (α × α)} {s : Set β}
    {f g : β → α} (hf : ∀ x ∈ s, ContinuousAt f x) (hg : ∀ x ∈ s, ContinuousAt g x)
    (hfg : s.EqOn f g) (hr : r ∈ 𝓤 α) :
    ∃ t, IsOpen t ∧ s ⊆ t ∧ ∀ x ∈ t, (f x, g x) ∈ r 
goal: ∃ t, IsOpen t ∧ s ⊆ t ∧ ∀ x ∈ t, (f x, g x) ∈ r

full_name: Filter.Tendsto.congr_uniformity
code: theorem Filter.Tendsto.congr_uniformity {α β} [UniformSpace β] {f g : α → β} {l : Filter α} {b : β}
    (hf : Tendsto f l (𝓝 b)) (hg : Tendsto (fun x => (f x, g x)) l (𝓤 β)) : Tendsto g l (𝓝 b) 
goal: Filter.Tendsto g l (𝓝 b)

full_name: Uniform.tendsto_congr
code: theorem Uniform.tendsto_congr {α β} [UniformSpace β] {f g : α → β} {l : Filter α} {b : β}
    (hfg : Tendsto (fun x => (f x, g x)) l (𝓤 β)) : Tendsto f l (𝓝 b) ↔ Tendsto g l (𝓝 b) 
goal: Filter.Tendsto f l (𝓝 b) ↔ Filter.Tendsto g l (𝓝 b)