ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- UniformOnFun.toFun_ofFun
@[simp] lemma UniformOnFun.toFun_ofFun (f : α → β) : toFun 𝔖 (ofFun 𝔖 f) = f 
Arguments: {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} (f : α → β)
Goal: (UniformOnFun.toFun 𝔖) ((UniformOnFun.ofFun 𝔖) f) = f
-- UniformOnFun.ofFun_toFun
@[simp] lemma UniformOnFun.ofFun_toFun (f : α →ᵤ[𝔖] β) : ofFun 𝔖 (toFun 𝔖 f) = f 
Arguments: {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} (f : α →ᵤ[𝔖] β)
Goal: (UniformOnFun.ofFun 𝔖) ((UniformOnFun.toFun 𝔖) f) = f
-- UniformFun.isBasis_gen
protected theorem isBasis_gen (𝓑 : Filter <| β × β) :
    IsBasis (fun V : Set (β × β) => V ∈ 𝓑) (UniformFun.gen α β) 
Arguments: (α : Type u_1) (β : Type u_2) (𝓑 : Filter (β × β))
Goal: Filter.IsBasis (fun V => V ∈ 𝓑) (UniformFun.gen α β)
-- UniformFun.gc
protected theorem gc : GaloisConnection lowerAdjoint fun 𝓕 => UniformFun.filter α β 𝓕 
Arguments: (α : Type u_1) (β : Type u_2)
Goal: GaloisConnection (fun 𝓐 => Filter.map (UniformFun.phi α β) (𝓐 ×ˢ ⊤)) fun 𝓕 => UniformFun.filter α β 𝓕
-- UniformFun.hasBasis_uniformity
protected theorem hasBasis_uniformity :
    (𝓤 (α →ᵤ β)).HasBasis (· ∈ 𝓤 β) (UniformFun.gen α β) 
Arguments: (α : Type u_1) (β : Type u_2) [UniformSpace β]
Goal: (𝓤 (α →ᵤ β)).HasBasis (fun x => x ∈ 𝓤 β) (UniformFun.gen α β)
-- UniformFun.hasBasis_uniformity_of_basis
protected theorem hasBasis_uniformity_of_basis {ι : Sort*} {p : ι → Prop} {s : ι → Set (β × β)}
    (h : (𝓤 β).HasBasis p s) : (𝓤 (α →ᵤ β)).HasBasis p (UniformFun.gen α β ∘ s) 
Arguments: (α : Type u_1) (β : Type u_2) [UniformSpace β] {ι : Sort u_5} {p : ι → Prop} {s : ι → Set (β × β)} (h : (𝓤 β).HasBasis p s)
Goal: (𝓤 (α →ᵤ β)).HasBasis p (UniformFun.gen α β ∘ s)
-- UniformFun.hasBasis_nhds_of_basis
protected theorem hasBasis_nhds_of_basis (f) {p : ι → Prop} {s : ι → Set (β × β)}
    (h : HasBasis (𝓤 β) p s) :
    (𝓝 f).HasBasis p fun i => { g | (f, g) ∈ UniformFun.gen α β (s i) } 
Arguments: (α : Type u_1) (β : Type u_2) {ι : Type u_4} [UniformSpace β] (f : α →ᵤ β) {p : ι → Prop} {s : ι → Set (β × β)} (h : (𝓤 β).HasBasis p s)
Goal: (𝓝 f).HasBasis p fun i => {g | (f, g) ∈ UniformFun.gen α β (s i)}
-- UniformFun.hasBasis_nhds
protected theorem hasBasis_nhds (f) :
    (𝓝 f).HasBasis (fun V => V ∈ 𝓤 β) fun V => { g | (f, g) ∈ UniformFun.gen α β V } 
Arguments: (α : Type u_1) (β : Type u_2) [UniformSpace β] (f : α →ᵤ β)
Goal: (𝓝 f).HasBasis (fun V => V ∈ 𝓤 β) fun V => {g | (f, g) ∈ UniformFun.gen α β V}
-- UniformFun.uniformContinuous_eval
theorem uniformContinuous_eval (x : α) :
    UniformContinuous (Function.eval x ∘ toFun : (α →ᵤ β) → β) 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] (x : α)
Goal: UniformContinuous (Function.eval x ∘ ⇑UniformFun.toFun)
-- UniformFun.mem_gen
@[simp]
protected lemma mem_gen {f g : α →ᵤ β} {V : Set (β × β)} :
    (f, g) ∈ UniformFun.gen α β V ↔ ∀ x, (toFun f x, toFun g x) ∈ V 
Arguments: {α : Type u_1} {β : Type u_2} {f g : α →ᵤ β} {V : Set (β × β)}
Goal: (f, g) ∈ UniformFun.gen α β V ↔ ∀ (x : α), (UniformFun.toFun f x, UniformFun.toFun g x) ∈ V
-- UniformFun.mono
protected theorem mono : Monotone (@UniformFun.uniformSpace α γ) 
Arguments: {α : Type u_1} {γ : Type u_3}
Goal: Monotone (@UniformFun.uniformSpace α γ)
-- UniformFun.iInf_eq
protected theorem iInf_eq {u : ι → UniformSpace γ} : 𝒰(α, γ, (⨅ i, u i)) = ⨅ i, 𝒰(α, γ, u i) 
Arguments: {α : Type u_1} {γ : Type u_3} {ι : Type u_4} {u : ι → UniformSpace γ}
Goal: UniformFun.uniformSpace α γ = ⨅ i, UniformFun.uniformSpace α γ
-- UniformFun.inf_eq
protected theorem inf_eq {u₁ u₂ : UniformSpace γ} :
    𝒰(α, γ, u₁ ⊓ u₂) = 𝒰(α, γ, u₁) ⊓ 𝒰(α, γ, u₂) 
Arguments: {α : Type u_1} {γ : Type u_3} {u₁ u₂ : UniformSpace γ}
Goal: UniformFun.uniformSpace α γ = UniformFun.uniformSpace α γ ⊓ UniformFun.uniformSpace α γ
-- UniformFun.postcomp_uniformInducing
protected theorem postcomp_uniformInducing [UniformSpace γ] {f : γ → β} (hf : UniformInducing f) :
    UniformInducing (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] [UniformSpace γ] {f : γ → β} (hf : UniformInducing f)
Goal: UniformInducing (⇑UniformFun.ofFun ∘ (fun x => f ∘ x) ∘ ⇑UniformFun.toFun)
-- UniformFun.postcomp_uniformEmbedding
protected theorem postcomp_uniformEmbedding [UniformSpace γ] {f : γ → β} (hf : UniformEmbedding f) :
    UniformEmbedding (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] [UniformSpace γ] {f : γ → β} (hf : UniformEmbedding f)
Goal: UniformEmbedding (⇑UniformFun.ofFun ∘ (fun x => f ∘ x) ∘ ⇑UniformFun.toFun)
-- UniformFun.comap_eq
protected theorem comap_eq {f : γ → β} :
    𝒰(α, γ, ‹UniformSpace β›.comap f) = 𝒰(α, β, _).comap (f ∘ ·) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] {f : γ → β}
Goal: UniformFun.uniformSpace α γ = UniformSpace.comap (fun x => f ∘ x) (UniformFun.uniformSpace α β)
-- UniformFun.postcomp_uniformContinuous
protected theorem postcomp_uniformContinuous [UniformSpace γ] {f : γ → β}
    (hf : UniformContinuous f) :
    UniformContinuous (ofFun ∘ (f ∘ ·) ∘ toFun : (α →ᵤ γ) → α →ᵤ β) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] [UniformSpace γ] {f : γ → β} (hf : UniformContinuous f)
Goal: UniformContinuous (⇑UniformFun.ofFun ∘ (fun x => f ∘ x) ∘ ⇑UniformFun.toFun)
-- UniformFun.precomp_uniformContinuous
protected theorem precomp_uniformContinuous {f : γ → α} :
    UniformContinuous fun g : α →ᵤ β => ofFun (toFun g ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] {f : γ → α}
Goal: UniformContinuous fun g => UniformFun.ofFun (UniformFun.toFun g ∘ f)
-- UniformFun.uniformContinuous_toFun
protected theorem uniformContinuous_toFun : UniformContinuous (toFun : (α →ᵤ β) → α → β) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β]
Goal: UniformContinuous ⇑UniformFun.toFun
-- UniformFun.tendsto_iff_tendstoUniformly
protected theorem tendsto_iff_tendstoUniformly {F : ι → α →ᵤ β} {f : α →ᵤ β} :
    Tendsto F p (𝓝 f) ↔ TendstoUniformly (toFun ∘ F) (toFun f) p 
Arguments: {α : Type u_1} {β : Type u_2} {ι : Type u_4} {p : Filter ι} [UniformSpace β] {F : ι → α →ᵤ β} {f : α →ᵤ β}
Goal: Filter.Tendsto F p (𝓝 f) ↔ TendstoUniformly (⇑UniformFun.toFun ∘ F) (UniformFun.toFun f) p
-- UniformFun.isClosed_setOf_continuous
theorem isClosed_setOf_continuous [TopologicalSpace α] :
    IsClosed {f : α →ᵤ β | Continuous (toFun f)} 
Arguments: (α : Type u_1) {β : Type u_2} [UniformSpace β] [TopologicalSpace α]
Goal: IsClosed {f | Continuous (UniformFun.toFun f)}
-- UniformFun.uniformSpace_eq_inf_precomp_of_cover
theorem uniformSpace_eq_inf_precomp_of_cover {δ₁ δ₂ : Type*} (φ₁ : δ₁ → α) (φ₂ : δ₂ → α)
    (h_cover : range φ₁ ∪ range φ₂ = univ) :
    𝒰(α, β, _) =
      .comap (ofFun ∘ (· ∘ φ₁) ∘ toFun) 𝒰(δ₁, β, _) ⊓
      .comap (ofFun ∘ (· ∘ φ₂) ∘ toFun) 𝒰(δ₂, β, _) 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] {δ₁ : Type u_6} {δ₂ : Type u_7} (φ₁ : δ₁ → α) (φ₂ : δ₂ → α) (h_cover : Set.range φ₁ ∪ Set.range φ₂ = Set.univ)
Goal: UniformFun.uniformSpace α β =
  UniformSpace.comap (⇑UniformFun.ofFun ∘ (fun x => x ∘ φ₁) ∘ ⇑UniformFun.toFun) (UniformFun.uniformSpace δ₁ β) ⊓
    UniformSpace.comap (⇑UniformFun.ofFun ∘ (fun x => x ∘ φ₂) ∘ ⇑UniformFun.toFun) (UniformFun.uniformSpace δ₂ β)
-- UniformFun.uniformSpace_eq_iInf_precomp_of_cover
theorem uniformSpace_eq_iInf_precomp_of_cover {δ : ι → Type*} (φ : Π i, δ i → α)
    (h_cover : ∃ I : Set ι, I.Finite ∧ ⋃ i ∈ I, range (φ i) = univ) :
    𝒰(α, β, _) = ⨅ i, .comap (ofFun ∘ (· ∘ φ i) ∘ toFun) 𝒰(δ i, β, _) 
Arguments: {α : Type u_1} (β : Type u_2) {ι : Type u_4} [UniformSpace β] {δ : ι → Type u_6} (φ : (i : ι) → δ i → α) (h_cover : ∃ I, I.Finite ∧ ⋃ i ∈ I, Set.range (φ i) = Set.univ)
Goal: UniformFun.uniformSpace α β =
  ⨅ i, UniformSpace.comap (⇑UniformFun.ofFun ∘ (fun x => x ∘ φ i) ∘ ⇑UniformFun.toFun) (UniformFun.uniformSpace (δ i) β)
-- UniformOnFun.gen_eq_preimage_restrict
protected theorem gen_eq_preimage_restrict {𝔖} (S : Set α) (V : Set (β × β)) :
    UniformOnFun.gen 𝔖 S V =
      Prod.map (S.restrict ∘ UniformFun.toFun) (S.restrict ∘ UniformFun.toFun) ⁻¹'
        UniformFun.gen S β V 
Arguments: {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} (S : Set α) (V : Set (β × β))
Goal: UniformOnFun.gen 𝔖 S V =
  Prod.map (S.restrict ∘ ⇑UniformFun.toFun) (S.restrict ∘ ⇑UniformFun.toFun) ⁻¹' UniformFun.gen (↑S) β V
-- UniformOnFun.gen_mono
protected theorem gen_mono {𝔖} {S S' : Set α} {V V' : Set (β × β)} (hS : S' ⊆ S) (hV : V ⊆ V') :
    UniformOnFun.gen 𝔖 S V ⊆ UniformOnFun.gen 𝔖 S' V' 
Arguments: {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} {S S' : Set α} {V V' : Set (β × β)} (hS : S' ⊆ S) (hV : V ⊆ V')
Goal: UniformOnFun.gen 𝔖 S V ⊆ UniformOnFun.gen 𝔖 S' V'
-- UniformOnFun.isBasis_gen
protected theorem isBasis_gen (𝔖 : Set (Set α)) (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖)
    (𝓑 : FilterBasis <| β × β) :
    IsBasis (fun SV : Set α × Set (β × β) => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓑) fun SV =>
      UniformOnFun.gen 𝔖 SV.1 SV.2 
Arguments: {α : Type u_1} {β : Type u_2} (𝔖 : Set (Set α)) (h : 𝔖.Nonempty) (h' : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖) (𝓑 : FilterBasis (β × β))
Goal: Filter.IsBasis (fun SV => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓑) fun SV => UniformOnFun.gen 𝔖 SV.1 SV.2
-- UniformOnFun.topologicalSpace_eq
protected theorem topologicalSpace_eq :
    UniformOnFun.topologicalSpace α β 𝔖 =
      ⨅ (s : Set α) (_ : s ∈ 𝔖), TopologicalSpace.induced
        (UniformFun.ofFun ∘ s.restrict ∘ toFun 𝔖) (UniformFun.topologicalSpace s β) 
Arguments: (α : Type u_1) (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α))
Goal: UniformOnFun.topologicalSpace α β 𝔖 =
  ⨅ s ∈ 𝔖,
    TopologicalSpace.induced (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(UniformOnFun.toFun 𝔖))
      (UniformFun.topologicalSpace (↑s) β)
-- UniformOnFun.hasBasis_uniformity_of_basis_aux₁
protected theorem hasBasis_uniformity_of_basis_aux₁ {p : ι → Prop} {s : ι → Set (β × β)}
    (hb : HasBasis (𝓤 β) p s) (S : Set α) :
    (@uniformity (α →ᵤ[𝔖] β) ((UniformFun.uniformSpace S β).comap S.restrict)).HasBasis p fun i =>
      UniformOnFun.gen 𝔖 S (s i) 
Arguments: (α : Type u_1) (β : Type u_2) {ι : Type u_4} [UniformSpace β] (𝔖 : Set (Set α)) {p : ι → Prop} {s : ι → Set (β × β)} (hb : (𝓤 β).HasBasis p s) (S : Set α)
Goal: (𝓤 (α →ᵤ[𝔖] β)).HasBasis p fun i => UniformOnFun.gen 𝔖 S (s i)
-- UniformOnFun.hasBasis_uniformity_of_basis_aux₂
protected theorem hasBasis_uniformity_of_basis_aux₂ (h : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop}
    {s : ι → Set (β × β)} (hb : HasBasis (𝓤 β) p s) :
    DirectedOn
      ((fun s : Set α => (UniformFun.uniformSpace s β).comap (s.restrict : (α →ᵤ β) → s →ᵤ β)) ⁻¹'o
        GE.ge)
      𝔖 
Arguments: (α : Type u_1) (β : Type u_2) {ι : Type u_4} [UniformSpace β] (𝔖 : Set (Set α)) (h : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖) {p : ι → Prop} {s : ι → Set (β × β)} (hb : (𝓤 β).HasBasis p s)
Goal: DirectedOn ((fun s => UniformSpace.comap s.restrict (UniformFun.uniformSpace (↑s) β)) ⁻¹'o GE.ge) 𝔖
-- UniformOnFun.hasBasis_uniformity_of_basis
protected theorem hasBasis_uniformity_of_basis (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖)
    {p : ι → Prop} {s : ι → Set (β × β)} (hb : HasBasis (𝓤 β) p s) :
    (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      UniformOnFun.gen 𝔖 Si.1 (s Si.2) 
Arguments: (α : Type u_1) (β : Type u_2) {ι : Type u_4} [UniformSpace β] (𝔖 : Set (Set α)) (h : 𝔖.Nonempty) (h' : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖) {p : ι → Prop} {s : ι → Set (β × β)} (hb : (𝓤 β).HasBasis p s)
Goal: (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => UniformOnFun.gen 𝔖 Si.1 (s Si.2)
-- UniformOnFun.hasBasis_uniformity
protected theorem hasBasis_uniformity (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖) :
    (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun SV : Set α × Set (β × β) => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓤 β) fun SV =>
      UniformOnFun.gen 𝔖 SV.1 SV.2 
Arguments: (α : Type u_1) (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α)) (h : 𝔖.Nonempty) (h' : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖)
Goal: (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun SV => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓤 β) fun SV => UniformOnFun.gen 𝔖 SV.1 SV.2
-- UniformOnFun.hasBasis_uniformity_of_covering_of_basis
protected theorem hasBasis_uniformity_of_covering_of_basis {ι ι' : Type*} [Nonempty ι]
    {t : ι → Set α} {p : ι' → Prop} {V : ι' → Set (β × β)} (ht : ∀ i, t i ∈ 𝔖)
    (hdir : Directed (· ⊆ ·) t) (hex : ∀ s ∈ 𝔖, ∃ i, s ⊆ t i) (hb : HasBasis (𝓤 β) p V) :
    (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun i : ι × ι' ↦ p i.2) fun i ↦
      UniformOnFun.gen 𝔖 (t i.1) (V i.2) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] (𝔖 : Set (Set α)) {ι : Type u_5} {ι' : Type u_6} [Nonempty ι] {t : ι → Set α} {p : ι' → Prop} {V : ι' → Set (β × β)} (ht : ∀ (i : ι), t i ∈ 𝔖) (hdir : Directed (fun x x_1 => x ⊆ x_1) t) (hex : ∀ s ∈ 𝔖, ∃ i, s ⊆ t i) (hb : (𝓤 β).HasBasis p V)
Goal: (𝓤 (α →ᵤ[𝔖] β)).HasBasis (fun i => p i.2) fun i => UniformOnFun.gen 𝔖 (t i.1) (V i.2)
-- UniformOnFun.hasAntitoneBasis_uniformity
protected theorem hasAntitoneBasis_uniformity {ι : Type*} [Preorder ι] [IsDirected ι (· ≤ ·)]
    {t : ι → Set α} {V : ι → Set (β × β)}
    (ht : ∀ n, t n ∈ 𝔖) (hmono : Monotone t) (hex : ∀ s ∈ 𝔖, ∃ n, s ⊆ t n)
    (hb : HasAntitoneBasis (𝓤 β) V) :
    (𝓤 (α →ᵤ[𝔖] β)).HasAntitoneBasis fun n ↦ UniformOnFun.gen 𝔖 (t n) (V n) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] (𝔖 : Set (Set α)) {ι : Type u_5} [Preorder ι] [IsDirected ι fun x x_1 => x ≤ x_1] {t : ι → Set α} {V : ι → Set (β × β)} (ht : ∀ (n : ι), t n ∈ 𝔖) (hmono : Monotone t) (hex : ∀ s ∈ 𝔖, ∃ n, s ⊆ t n) (hb : (𝓤 β).HasAntitoneBasis V)
Goal: (𝓤 (α →ᵤ[𝔖] β)).HasAntitoneBasis fun n => UniformOnFun.gen 𝔖 (t n) (V n)
-- UniformOnFun.isCountablyGenerated_uniformity
protected theorem isCountablyGenerated_uniformity [IsCountablyGenerated (𝓤 β)] {t : ℕ → Set α}
    (ht : ∀ n, t n ∈ 𝔖) (hmono : Monotone t) (hex : ∀ s ∈ 𝔖, ∃ n, s ⊆ t n) :
    IsCountablyGenerated (𝓤 (α →ᵤ[𝔖] β)) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] (𝔖 : Set (Set α)) [(𝓤 β).IsCountablyGenerated] {t : ℕ → Set α} (ht : ∀ (n : ℕ), t n ∈ 𝔖) (hmono : Monotone t) (hex : ∀ s ∈ 𝔖, ∃ n, s ⊆ t n)
Goal: (𝓤 (α →ᵤ[𝔖] β)).IsCountablyGenerated
-- UniformOnFun.hasBasis_nhds_of_basis
protected theorem hasBasis_nhds_of_basis (f : α →ᵤ[𝔖] β) (h : 𝔖.Nonempty)
    (h' : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {s : ι → Set (β × β)} (hb : HasBasis (𝓤 β) p s) :
    (𝓝 f).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      { g | (g, f) ∈ UniformOnFun.gen 𝔖 Si.1 (s Si.2) } 
Arguments: (α : Type u_1) (β : Type u_2) {ι : Type u_4} [UniformSpace β] (𝔖 : Set (Set α)) (f : α →ᵤ[𝔖] β) (h : 𝔖.Nonempty) (h' : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖) {p : ι → Prop} {s : ι → Set (β × β)} (hb : (𝓤 β).HasBasis p s)
Goal: (𝓝 f).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {g | (g, f) ∈ UniformOnFun.gen 𝔖 Si.1 (s Si.2)}
-- UniformOnFun.hasBasis_nhds
protected theorem hasBasis_nhds (f : α →ᵤ[𝔖] β) (h : 𝔖.Nonempty) (h' : DirectedOn (· ⊆ ·) 𝔖) :
    (𝓝 f).HasBasis (fun SV : Set α × Set (β × β) => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓤 β) fun SV =>
      { g | (g, f) ∈ UniformOnFun.gen 𝔖 SV.1 SV.2 } 
Arguments: (α : Type u_1) (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α)) (f : α →ᵤ[𝔖] β) (h : 𝔖.Nonempty) (h' : DirectedOn (fun x x_1 => x ⊆ x_1) 𝔖)
Goal: (𝓝 f).HasBasis (fun SV => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓤 β) fun SV => {g | (g, f) ∈ UniformOnFun.gen 𝔖 SV.1 SV.2}
-- UniformOnFun.uniformContinuous_restrict
protected theorem uniformContinuous_restrict (h : s ∈ 𝔖) :
    UniformContinuous (UniformFun.ofFun ∘ (s.restrict : (α → β) → s → β) ∘ toFun 𝔖) 
Arguments: (α : Type u_1) (β : Type u_2) {s : Set α} [UniformSpace β] (𝔖 : Set (Set α)) (h : s ∈ 𝔖)
Goal: UniformContinuous (⇑UniformFun.ofFun ∘ s.restrict ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.uniformity_eq_of_basis
protected theorem uniformity_eq_of_basis {ι : Sort*} {p : ι → Prop} {V : ι → Set (β × β)}
    (h : (𝓤 β).HasBasis p V) :
    𝓤 (α →ᵤ[𝔖] β) = ⨅ s ∈ 𝔖, ⨅ (i) (_ : p i), 𝓟 (UniformOnFun.gen 𝔖 s (V i)) 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α)) {ι : Sort u_5} {p : ι → Prop} {V : ι → Set (β × β)} (h : (𝓤 β).HasBasis p V)
Goal: 𝓤 (α →ᵤ[𝔖] β) = ⨅ s ∈ 𝔖, ⨅ i, ⨅ (_ : p i), 𝓟 (UniformOnFun.gen 𝔖 s (V i))
-- UniformOnFun.uniformity_eq
protected theorem uniformity_eq : 𝓤 (α →ᵤ[𝔖] β) = ⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 (UniformOnFun.gen 𝔖 s V) 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α))
Goal: 𝓤 (α →ᵤ[𝔖] β) = ⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 (UniformOnFun.gen 𝔖 s V)
-- UniformOnFun.gen_mem_uniformity
protected theorem gen_mem_uniformity (hs : s ∈ 𝔖) {V : Set (β × β)} (hV : V ∈ 𝓤 β) :
    UniformOnFun.gen 𝔖 s V ∈ 𝓤 (α →ᵤ[𝔖] β) 
Arguments: {α : Type u_1} (β : Type u_2) {s : Set α} [UniformSpace β] (𝔖 : Set (Set α)) (hs : s ∈ 𝔖) {V : Set (β × β)} (hV : V ∈ 𝓤 β)
Goal: UniformOnFun.gen 𝔖 s V ∈ 𝓤 (α →ᵤ[𝔖] β)
-- UniformOnFun.nhds_eq_of_basis
protected theorem nhds_eq_of_basis {ι : Sort*} {p : ι → Prop} {V : ι → Set (β × β)}
    (h : (𝓤 β).HasBasis p V) (f : α →ᵤ[𝔖] β) :
    𝓝 f = ⨅ s ∈ 𝔖, ⨅ (i) (_ : p i), 𝓟 {g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V i} 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α)) {ι : Sort u_5} {p : ι → Prop} {V : ι → Set (β × β)} (h : (𝓤 β).HasBasis p V) (f : α →ᵤ[𝔖] β)
Goal: 𝓝 f = ⨅ s ∈ 𝔖, ⨅ i, ⨅ (_ : p i), 𝓟 {g | ∀ x ∈ s, ((UniformOnFun.toFun 𝔖) f x, (UniformOnFun.toFun 𝔖) g x) ∈ V i}
-- UniformOnFun.nhds_eq
protected theorem nhds_eq (f : α →ᵤ[𝔖] β) :
    𝓝 f = ⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 {g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V} 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α)) (f : α →ᵤ[𝔖] β)
Goal: 𝓝 f = ⨅ s ∈ 𝔖, ⨅ V ∈ 𝓤 β, 𝓟 {g | ∀ x ∈ s, ((UniformOnFun.toFun 𝔖) f x, (UniformOnFun.toFun 𝔖) g x) ∈ V}
-- UniformOnFun.gen_mem_nhds
protected theorem gen_mem_nhds (f : α →ᵤ[𝔖] β) (hs : s ∈ 𝔖) {V : Set (β × β)} (hV : V ∈ 𝓤 β) :
    {g | ∀ x ∈ s, (toFun 𝔖 f x, toFun 𝔖 g x) ∈ V} ∈ 𝓝 f 
Arguments: {α : Type u_1} (β : Type u_2) {s : Set α} [UniformSpace β] (𝔖 : Set (Set α)) (f : α →ᵤ[𝔖] β) (hs : s ∈ 𝔖) {V : Set (β × β)} (hV : V ∈ 𝓤 β)
Goal: {g | ∀ x ∈ s, ((UniformOnFun.toFun 𝔖) f x, (UniformOnFun.toFun 𝔖) g x) ∈ V} ∈ 𝓝 f
-- UniformOnFun.uniformContinuous_ofUniformFun
theorem uniformContinuous_ofUniformFun :
    UniformContinuous fun f : α →ᵤ β ↦ ofFun 𝔖 (UniformFun.toFun f) 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α))
Goal: UniformContinuous fun f => (UniformOnFun.ofFun 𝔖) (UniformFun.toFun f)
-- UniformOnFun.mono
protected theorem mono ⦃u₁ u₂ : UniformSpace γ⦄ (hu : u₁ ≤ u₂) ⦃𝔖₁ 𝔖₂ : Set (Set α)⦄
    (h𝔖 : 𝔖₂ ⊆ 𝔖₁) : 𝒱(α, γ, 𝔖₁, u₁) ≤ 𝒱(α, γ, 𝔖₂, u₂) 
Arguments: {α : Type u_1} {γ : Type u_3} ⦃u₁ u₂ : UniformSpace γ⦄ (hu : u₁ ≤ u₂) ⦃𝔖₁ 𝔖₂ : Set (Set α)⦄ (h𝔖 : 𝔖₂ ⊆ 𝔖₁)
Goal: UniformOnFun.uniformSpace α γ 𝔖₁ ≤ UniformOnFun.uniformSpace α γ 𝔖₂
-- UniformOnFun.uniformContinuous_eval_of_mem
theorem uniformContinuous_eval_of_mem {x : α} (hxs : x ∈ s) (hs : s ∈ 𝔖) :
    UniformContinuous ((Function.eval x : (α → β) → β) ∘ toFun 𝔖) 
Arguments: {α : Type u_1} (β : Type u_2) {s : Set α} [UniformSpace β] (𝔖 : Set (Set α)) {x : α} (hxs : x ∈ s) (hs : s ∈ 𝔖)
Goal: UniformContinuous (Function.eval x ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.uniformContinuous_eval_of_mem_sUnion
theorem uniformContinuous_eval_of_mem_sUnion {x : α} (hx : x ∈ ⋃₀ 𝔖) :
    UniformContinuous ((Function.eval x : (α → β) → β) ∘ toFun 𝔖) 
Arguments: {α : Type u_1} (β : Type u_2) [UniformSpace β] (𝔖 : Set (Set α)) {x : α} (hx : x ∈ ⋃₀ 𝔖)
Goal: UniformContinuous (Function.eval x ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.uniformContinuous_eval
theorem uniformContinuous_eval (h : ⋃₀ 𝔖 = univ) (x : α) :
    UniformContinuous ((Function.eval x : (α → β) → β) ∘ toFun 𝔖) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] {𝔖 : Set (Set α)} (h : ⋃₀ 𝔖 = Set.univ) (x : α)
Goal: UniformContinuous (Function.eval x ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.iInf_eq
protected theorem iInf_eq {u : ι → UniformSpace γ} :
    𝒱(α, γ, 𝔖, ⨅ i, u i) = ⨅ i, 𝒱(α, γ, 𝔖, u i) 
Arguments: {α : Type u_1} {γ : Type u_3} {ι : Type u_4} {𝔖 : Set (Set α)} {u : ι → UniformSpace γ}
Goal: UniformOnFun.uniformSpace α γ 𝔖 = ⨅ i, UniformOnFun.uniformSpace α γ 𝔖
-- UniformOnFun.inf_eq
protected theorem inf_eq {u₁ u₂ : UniformSpace γ} :
    𝒱(α, γ, 𝔖, u₁ ⊓ u₂) = 𝒱(α, γ, 𝔖, u₁) ⊓ 𝒱(α, γ, 𝔖, u₂) 
Arguments: {α : Type u_1} {γ : Type u_3} {𝔖 : Set (Set α)} {u₁ u₂ : UniformSpace γ}
Goal: UniformOnFun.uniformSpace α γ 𝔖 = UniformOnFun.uniformSpace α γ 𝔖 ⊓ UniformOnFun.uniformSpace α γ 𝔖
-- UniformOnFun.comap_eq
protected theorem comap_eq {f : γ → β} :
    𝒱(α, γ, 𝔖, ‹UniformSpace β›.comap f) = 𝒱(α, β, 𝔖, _).comap (f ∘ ·) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] {𝔖 : Set (Set α)} {f : γ → β}
Goal: UniformOnFun.uniformSpace α γ 𝔖 = UniformSpace.comap (fun x => f ∘ x) (UniformOnFun.uniformSpace α β 𝔖)
-- UniformOnFun.postcomp_uniformContinuous
protected theorem postcomp_uniformContinuous [UniformSpace γ] {f : γ → β}
    (hf : UniformContinuous f) : UniformContinuous (ofFun 𝔖 ∘ (f ∘ ·) ∘ toFun 𝔖) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] {𝔖 : Set (Set α)} [UniformSpace γ] {f : γ → β} (hf : UniformContinuous f)
Goal: UniformContinuous (⇑(UniformOnFun.ofFun 𝔖) ∘ (fun x => f ∘ x) ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.postcomp_uniformInducing
protected theorem postcomp_uniformInducing [UniformSpace γ] {f : γ → β} (hf : UniformInducing f) :
    UniformInducing (ofFun 𝔖 ∘ (f ∘ ·) ∘ toFun 𝔖) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] {𝔖 : Set (Set α)} [UniformSpace γ] {f : γ → β} (hf : UniformInducing f)
Goal: UniformInducing (⇑(UniformOnFun.ofFun 𝔖) ∘ (fun x => f ∘ x) ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.postcomp_uniformEmbedding
protected theorem postcomp_uniformEmbedding [UniformSpace γ] {f : γ → β} (hf : UniformEmbedding f) :
    UniformEmbedding (ofFun 𝔖 ∘ (f ∘ ·) ∘ toFun 𝔖) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] {𝔖 : Set (Set α)} [UniformSpace γ] {f : γ → β} (hf : UniformEmbedding f)
Goal: UniformEmbedding (⇑(UniformOnFun.ofFun 𝔖) ∘ (fun x => f ∘ x) ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.precomp_uniformContinuous
protected theorem precomp_uniformContinuous {𝔗 : Set (Set γ)} {f : γ → α}
    (hf : MapsTo (f '' ·) 𝔗 𝔖) :
    UniformContinuous fun g : α →ᵤ[𝔖] β => ofFun 𝔗 (toFun 𝔖 g ∘ f) 
Arguments: {α : Type u_1} {β : Type u_2} {γ : Type u_3} [UniformSpace β] {𝔖 : Set (Set α)} {𝔗 : Set (Set γ)} {f : γ → α} (hf : Set.MapsTo (fun x => f '' x) 𝔗 𝔖)
Goal: UniformContinuous fun g => (UniformOnFun.ofFun 𝔗) ((UniformOnFun.toFun 𝔖) g ∘ f)
-- UniformOnFun.t2Space_of_covering
theorem t2Space_of_covering [T2Space β] (h : ⋃₀ 𝔖 = univ) : T2Space (α →ᵤ[𝔖] β) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] {𝔖 : Set (Set α)} [T2Space β] (h : ⋃₀ 𝔖 = Set.univ)
Goal: T2Space (α →ᵤ[𝔖] β)
-- UniformOnFun.uniformContinuous_restrict_toFun
theorem uniformContinuous_restrict_toFun :
    UniformContinuous ((⋃₀ 𝔖).restrict ∘ toFun 𝔖 : (α →ᵤ[𝔖] β) → ⋃₀ 𝔖 → β) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] {𝔖 : Set (Set α)}
Goal: UniformContinuous ((⋃₀ 𝔖).restrict ∘ ⇑(UniformOnFun.toFun 𝔖))
-- UniformOnFun.uniformContinuous_toFun
protected theorem uniformContinuous_toFun (h : ⋃₀ 𝔖 = univ) :
    UniformContinuous (toFun 𝔖 : (α →ᵤ[𝔖] β) → α → β) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] {𝔖 : Set (Set α)} (h : ⋃₀ 𝔖 = Set.univ)
Goal: UniformContinuous ⇑(UniformOnFun.toFun 𝔖)
-- UniformOnFun.continuousAt_eval₂
protected theorem continuousAt_eval₂ [TopologicalSpace α] {f : α →ᵤ[𝔖] β} {x : α}
    (h𝔖 : ∃ V ∈ 𝔖, V ∈ 𝓝 x) (hc : ContinuousAt (toFun 𝔖 f) x) :
    ContinuousAt (fun fx : (α →ᵤ[𝔖] β) × α ↦ toFun 𝔖 fx.1 fx.2) (f, x) 
Arguments: {α : Type u_1} {β : Type u_2} [UniformSpace β] {𝔖 : Set (Set α)} [TopologicalSpace α] {f : α →ᵤ[𝔖] β} {x : α} (h𝔖 : ∃ V ∈ 𝔖, V ∈ 𝓝 x) (hc : ContinuousAt ((UniformOnFun.toFun 𝔖) f) x)
Goal: ContinuousAt (fun fx => (UniformOnFun.toFun 𝔖) fx.1 fx.2) (f, x)