File: Mathlib/Topology/Algebra/UniformConvergence.lean

full_name: instOneUniformFun
code: @[to_additive] instance [One β] : One (α →ᵤ β) 
goal: One (α →ᵤ β)

full_name: instZeroUniformFun
code: @[to_additive] instance [One β] : One (α →ᵤ β) 
goal: Zero (α →ᵤ β)

full_name: UniformFun.toFun_zero
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_one [One β] : toFun (1 : α →ᵤ β) = 1 
goal: UniformFun.toFun 0 = 0

full_name: UniformFun.toFun_one
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_one [One β] : toFun (1 : α →ᵤ β) = 1 
goal: UniformFun.toFun 1 = 1

full_name: UniformFun.ofFun_one
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_one [One β] : ofFun (1 : α → β) = 1 
goal: UniformFun.ofFun 1 = 1

full_name: UniformFun.ofFun_zero
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_one [One β] : ofFun (1 : α → β) = 1 
goal: UniformFun.ofFun 0 = 0

full_name: instZeroUniformOnFun
code: @[to_additive] instance [One β] : One (α →ᵤ[𝔖] β) 
goal: Zero (α →ᵤ[𝔖] β)

full_name: instOneUniformOnFun
code: @[to_additive] instance [One β] : One (α →ᵤ[𝔖] β) 
goal: One (α →ᵤ[𝔖] β)

full_name: UniformOnFun.toFun_one
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_one [One β] : toFun 𝔖 (1 : α →ᵤ[𝔖] β) = 1 
goal: (UniformOnFun.toFun 𝔖) 1 = 1

full_name: UniformOnFun.toFun_zero
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_one [One β] : toFun 𝔖 (1 : α →ᵤ[𝔖] β) = 1 
goal: (UniformOnFun.toFun 𝔖) 0 = 0

full_name: UniformOnFun.zero_apply
code: @[to_additive (attr := simp)]
lemma UniformOnFun.one_apply [One β] : ofFun 𝔖 (1 : α → β) = 1 
goal: (UniformOnFun.ofFun 𝔖) 0 = 0

full_name: UniformOnFun.one_apply
code: @[to_additive (attr := simp)]
lemma UniformOnFun.one_apply [One β] : ofFun 𝔖 (1 : α → β) = 1 
goal: (UniformOnFun.ofFun 𝔖) 1 = 1

full_name: instMulUniformFun
code: @[to_additive] instance [Mul β] : Mul (α →ᵤ β) 
goal: Mul (α →ᵤ β)

full_name: instAddUniformFun
code: @[to_additive] instance [Mul β] : Mul (α →ᵤ β) 
goal: Add (α →ᵤ β)

full_name: UniformFun.toFun_mul
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_mul [Mul β] (f g : α →ᵤ β) : toFun (f * g) = toFun f * toFun g 
goal: UniformFun.toFun (f * g) = UniformFun.toFun f * UniformFun.toFun g

full_name: UniformFun.toFun_add
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_mul [Mul β] (f g : α →ᵤ β) : toFun (f * g) = toFun f * toFun g 
goal: UniformFun.toFun (f + g) = UniformFun.toFun f + UniformFun.toFun g

full_name: UniformFun.ofFun_mul
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_mul [Mul β] (f g : α → β) : ofFun (f * g) = ofFun f * ofFun g 
goal: UniformFun.ofFun (f * g) = UniformFun.ofFun f * UniformFun.ofFun g

full_name: UniformFun.ofFun_add
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_mul [Mul β] (f g : α → β) : ofFun (f * g) = ofFun f * ofFun g 
goal: UniformFun.ofFun (f + g) = UniformFun.ofFun f + UniformFun.ofFun g

full_name: instAddUniformOnFun
code: @[to_additive] instance [Mul β] : Mul (α →ᵤ[𝔖] β) 
goal: Add (α →ᵤ[𝔖] β)

full_name: instMulUniformOnFun
code: @[to_additive] instance [Mul β] : Mul (α →ᵤ[𝔖] β) 
goal: Mul (α →ᵤ[𝔖] β)

full_name: UniformOnFun.toFun_add
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_mul [Mul β] (f g : α →ᵤ[𝔖] β) :
    toFun 𝔖 (f * g) = toFun 𝔖 f * toFun 𝔖 g 
goal: (UniformOnFun.toFun 𝔖) (f + g) = (UniformOnFun.toFun 𝔖) f + (UniformOnFun.toFun 𝔖) g

full_name: UniformOnFun.toFun_mul
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_mul [Mul β] (f g : α →ᵤ[𝔖] β) :
    toFun 𝔖 (f * g) = toFun 𝔖 f * toFun 𝔖 g 
goal: (UniformOnFun.toFun 𝔖) (f * g) = (UniformOnFun.toFun 𝔖) f * (UniformOnFun.toFun 𝔖) g

full_name: UniformOnFun.ofFun_mul
code: @[to_additive (attr := simp)]
lemma UniformOnFun.ofFun_mul [Mul β] (f g : α → β) : ofFun 𝔖 (f * g) = ofFun 𝔖 f * ofFun 𝔖 g 
goal: (UniformOnFun.ofFun 𝔖) (f * g) = (UniformOnFun.ofFun 𝔖) f * (UniformOnFun.ofFun 𝔖) g

full_name: UniformOnFun.ofFun_add
code: @[to_additive (attr := simp)]
lemma UniformOnFun.ofFun_mul [Mul β] (f g : α → β) : ofFun 𝔖 (f * g) = ofFun 𝔖 f * ofFun 𝔖 g 
goal: (UniformOnFun.ofFun 𝔖) (f + g) = (UniformOnFun.ofFun 𝔖) f + (UniformOnFun.ofFun 𝔖) g

full_name: instNegUniformFun
code: @[to_additive] instance [Inv β] : Inv (α →ᵤ β) 
goal: Neg (α →ᵤ β)

full_name: instInvUniformFun
code: @[to_additive] instance [Inv β] : Inv (α →ᵤ β) 
goal: Inv (α →ᵤ β)

full_name: UniformFun.toFun_inv
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_inv [Inv β] (f : α →ᵤ β) : toFun (f⁻¹) = (toFun f)⁻¹ 
goal: UniformFun.toFun f⁻¹ = (UniformFun.toFun f)⁻¹

full_name: UniformFun.toFun_neg
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_inv [Inv β] (f : α →ᵤ β) : toFun (f⁻¹) = (toFun f)⁻¹ 
goal: UniformFun.toFun (-f) = -UniformFun.toFun f

full_name: UniformFun.ofFun_neg
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_inv [Inv β] (f : α → β) : ofFun (f⁻¹) = (ofFun f)⁻¹ 
goal: UniformFun.ofFun (-f) = -UniformFun.ofFun f

full_name: UniformFun.ofFun_inv
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_inv [Inv β] (f : α → β) : ofFun (f⁻¹) = (ofFun f)⁻¹ 
goal: UniformFun.ofFun f⁻¹ = (UniformFun.ofFun f)⁻¹

full_name: instNegUniformOnFun
code: @[to_additive] instance [Inv β] : Inv (α →ᵤ[𝔖] β) 
goal: Neg (α →ᵤ[𝔖] β)

full_name: instInvUniformOnFun
code: @[to_additive] instance [Inv β] : Inv (α →ᵤ[𝔖] β) 
goal: Inv (α →ᵤ[𝔖] β)

full_name: UniformOnFun.toFun_inv
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_inv [Inv β] (f : α →ᵤ[𝔖] β) : toFun 𝔖 (f⁻¹) = (toFun 𝔖 f)⁻¹ 
goal: (UniformOnFun.toFun 𝔖) f⁻¹ = ((UniformOnFun.toFun 𝔖) f)⁻¹

full_name: UniformOnFun.toFun_neg
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_inv [Inv β] (f : α →ᵤ[𝔖] β) : toFun 𝔖 (f⁻¹) = (toFun 𝔖 f)⁻¹ 
goal: (UniformOnFun.toFun 𝔖) (-f) = -(UniformOnFun.toFun 𝔖) f

full_name: UniformOnFun.ofFun_neg
code: @[to_additive (attr := simp)]
lemma UniformOnFun.ofFun_inv [Inv β] (f : α → β) : ofFun 𝔖 (f⁻¹) = (ofFun 𝔖 f)⁻¹ 
goal: (UniformOnFun.ofFun 𝔖) (-f) = -(UniformOnFun.ofFun 𝔖) f

full_name: UniformOnFun.ofFun_inv
code: @[to_additive (attr := simp)]
lemma UniformOnFun.ofFun_inv [Inv β] (f : α → β) : ofFun 𝔖 (f⁻¹) = (ofFun 𝔖 f)⁻¹ 
goal: (UniformOnFun.ofFun 𝔖) f⁻¹ = ((UniformOnFun.ofFun 𝔖) f)⁻¹

full_name: instSubUniformFun
code: @[to_additive] instance [Div β] : Div (α →ᵤ β) 
goal: Sub (α →ᵤ β)

full_name: instDivUniformFun
code: @[to_additive] instance [Div β] : Div (α →ᵤ β) 
goal: Div (α →ᵤ β)

full_name: UniformFun.toFun_div
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_div [Div β] (f g : α →ᵤ β) : toFun (f / g) = toFun f / toFun g 
goal: UniformFun.toFun (f / g) = UniformFun.toFun f / UniformFun.toFun g

full_name: UniformFun.toFun_sub
code: @[to_additive (attr := simp)]
lemma UniformFun.toFun_div [Div β] (f g : α →ᵤ β) : toFun (f / g) = toFun f / toFun g 
goal: UniformFun.toFun (f - g) = UniformFun.toFun f - UniformFun.toFun g

full_name: UniformFun.ofFun_div
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_div [Div β] (f g : α → β) : ofFun (f / g) = ofFun f / ofFun g 
goal: UniformFun.ofFun (f / g) = UniformFun.ofFun f / UniformFun.ofFun g

full_name: UniformFun.ofFun_sub
code: @[to_additive (attr := simp)]
lemma UniformFun.ofFun_div [Div β] (f g : α → β) : ofFun (f / g) = ofFun f / ofFun g 
goal: UniformFun.ofFun (f - g) = UniformFun.ofFun f - UniformFun.ofFun g

full_name: instDivUniformOnFun
code: @[to_additive] instance [Div β] : Div (α →ᵤ[𝔖] β) 
goal: Div (α →ᵤ[𝔖] β)

full_name: instSubUniformOnFun
code: @[to_additive] instance [Div β] : Div (α →ᵤ[𝔖] β) 
goal: Sub (α →ᵤ[𝔖] β)

full_name: UniformOnFun.toFun_sub
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_div [Div β] (f g : α →ᵤ[𝔖] β) :
    toFun 𝔖 (f / g) = toFun 𝔖 f / toFun 𝔖 g 
goal: (UniformOnFun.toFun 𝔖) (f - g) = (UniformOnFun.toFun 𝔖) f - (UniformOnFun.toFun 𝔖) g

full_name: UniformOnFun.toFun_div
code: @[to_additive (attr := simp)]
lemma UniformOnFun.toFun_div [Div β] (f g : α →ᵤ[𝔖] β) :
    toFun 𝔖 (f / g) = toFun 𝔖 f / toFun 𝔖 g 
goal: (UniformOnFun.toFun 𝔖) (f / g) = (UniformOnFun.toFun 𝔖) f / (UniformOnFun.toFun 𝔖) g

full_name: UniformOnFun.ofFun_sub
code: @[to_additive (attr := simp)]
lemma UniformOnFun.ofFun_div [Div β] (f g : α → β) : ofFun 𝔖 (f / g) = ofFun 𝔖 f / ofFun 𝔖 g 
goal: (UniformOnFun.ofFun 𝔖) (f - g) = (UniformOnFun.ofFun 𝔖) f - (UniformOnFun.ofFun 𝔖) g

full_name: UniformOnFun.ofFun_div
code: @[to_additive (attr := simp)]
lemma UniformOnFun.ofFun_div [Div β] (f g : α → β) : ofFun 𝔖 (f / g) = ofFun 𝔖 f / ofFun 𝔖 g 
goal: (UniformOnFun.ofFun 𝔖) (f / g) = (UniformOnFun.ofFun 𝔖) f / (UniformOnFun.ofFun 𝔖) g

full_name: instAddMonoidUniformFun
code: @[to_additive]
instance [Monoid β] : Monoid (α →ᵤ β) 
goal: AddMonoid (α →ᵤ β)

full_name: instMonoidUniformFun
code: @[to_additive]
instance [Monoid β] : Monoid (α →ᵤ β) 
goal: Monoid (α →ᵤ β)

full_name: instMonoidUniformOnFun
code: @[to_additive]
instance [Monoid β] : Monoid (α →ᵤ[𝔖] β) 
goal: Monoid (α →ᵤ[𝔖] β)

full_name: instAddMonoidUniformOnFun
code: @[to_additive]
instance [Monoid β] : Monoid (α →ᵤ[𝔖] β) 
goal: AddMonoid (α →ᵤ[𝔖] β)

full_name: instAddCommMonoidUniformFun
code: @[to_additive]
instance [CommMonoid β] : CommMonoid (α →ᵤ β) 
goal: AddCommMonoid (α →ᵤ β)

full_name: instCommMonoidUniformFun
code: @[to_additive]
instance [CommMonoid β] : CommMonoid (α →ᵤ β) 
goal: CommMonoid (α →ᵤ β)

full_name: instAddCommMonoidUniformOnFun
code: @[to_additive]
instance [CommMonoid β] : CommMonoid (α →ᵤ[𝔖] β) 
goal: AddCommMonoid (α →ᵤ[𝔖] β)

full_name: instCommMonoidUniformOnFun
code: @[to_additive]
instance [CommMonoid β] : CommMonoid (α →ᵤ[𝔖] β) 
goal: CommMonoid (α →ᵤ[𝔖] β)

full_name: instGroupUniformFun
code: @[to_additive]
instance [Group β] : Group (α →ᵤ β) 
goal: Group (α →ᵤ β)

full_name: instAddGroupUniformFun
code: @[to_additive]
instance [Group β] : Group (α →ᵤ β) 
goal: AddGroup (α →ᵤ β)

full_name: instGroupUniformOnFun
code: @[to_additive]
instance [Group β] : Group (α →ᵤ[𝔖] β) 
goal: Group (α →ᵤ[𝔖] β)

full_name: instAddGroupUniformOnFun
code: @[to_additive]
instance [Group β] : Group (α →ᵤ[𝔖] β) 
goal: AddGroup (α →ᵤ[𝔖] β)

full_name: instCommGroupUniformFun
code: @[to_additive]
instance [CommGroup β] : CommGroup (α →ᵤ β) 
goal: CommGroup (α →ᵤ β)

full_name: instAddCommGroupUniformFun
code: @[to_additive]
instance [CommGroup β] : CommGroup (α →ᵤ β) 
goal: AddCommGroup (α →ᵤ β)

full_name: instCommGroupUniformOnFun
code: @[to_additive]
instance [CommGroup β] : CommGroup (α →ᵤ[𝔖] β) 
goal: CommGroup (α →ᵤ[𝔖] β)

full_name: instAddCommGroupUniformOnFun
code: @[to_additive]
instance [CommGroup β] : CommGroup (α →ᵤ[𝔖] β) 
goal: AddCommGroup (α →ᵤ[𝔖] β)

full_name: instSMulUniformFun
code: instance {M : Type*} [SMul M β] : SMul M (α →ᵤ β) 
goal: SMul M (α →ᵤ β)

full_name: UniformFun.toFun_smul
code: @[simp]
lemma UniformFun.toFun_smul {M : Type*} [SMul M β] (c : M) (f : α →ᵤ β) :
    toFun (c • f) = c • toFun f 
goal: UniformFun.toFun (c • f) = c • UniformFun.toFun f

full_name: UniformFun.ofFun_smul
code: @[simp]
lemma UniformFun.ofFun_smul {M : Type*} [SMul M β] (c : M) (f : α → β) :
    ofFun (c • f) = c • ofFun f 
goal: UniformFun.ofFun (c • f) = c • UniformFun.ofFun f

full_name: instSMulUniformOnFun
code: instance {M : Type*} [SMul M β] : SMul M (α →ᵤ[𝔖] β) 
goal: SMul M (α →ᵤ[𝔖] β)

full_name: UniformOnFun.toFun_smul
code: @[simp]
lemma UniformOnFun.toFun_smul {M : Type*} [SMul M β] (c : M) (f : α →ᵤ[𝔖] β) :
    toFun 𝔖 (c • f) = c • toFun 𝔖 f 
goal: (UniformOnFun.toFun 𝔖) (c • f) = c • (UniformOnFun.toFun 𝔖) f

full_name: UniformOnFun.ofFun_smul
code: @[simp]
lemma UniformOnFun.ofFun_smul {M : Type*} [SMul M β] (c : M) (f : α → β) :
    ofFun 𝔖 (c • f) = c • ofFun 𝔖 f 
goal: (UniformOnFun.ofFun 𝔖) (c • f) = c • (UniformOnFun.ofFun 𝔖) f

full_name: instIsScalarTowerUniformFun
code: instance {M N : Type*} [SMul M N] [SMul M β] [SMul N β] [IsScalarTower M N β] :
    IsScalarTower M N (α →ᵤ β) 
goal: IsScalarTower M N (α →ᵤ β)

full_name: instIsScalarTowerUniformOnFun
code: instance {M N : Type*} [SMul M N] [SMul M β] [SMul N β] [IsScalarTower M N β] :
    IsScalarTower M N (α →ᵤ[𝔖] β) 
goal: IsScalarTower M N (α →ᵤ[𝔖] β)

full_name: instSMulCommClassUniformFun
code: instance {M N : Type*} [SMul M β] [SMul N β] [SMulCommClass M N β] :
    SMulCommClass M N (α →ᵤ β) 
goal: SMulCommClass M N (α →ᵤ β)

full_name: instSMulCommClassUniformOnFun
code: instance {M N : Type*} [SMul M β] [SMul N β] [SMulCommClass M N β] :
    SMulCommClass M N (α →ᵤ[𝔖] β) 
goal: SMulCommClass M N (α →ᵤ[𝔖] β)

full_name: instMulActionUniformFun
code: instance {M : Type*} [Monoid M] [MulAction M β] : MulAction M (α →ᵤ β) 
goal: MulAction M (α →ᵤ β)

full_name: instMulActionUniformOnFun
code: instance {M : Type*} [Monoid M] [MulAction M β] : MulAction M (α →ᵤ[𝔖] β) 
goal: MulAction M (α →ᵤ[𝔖] β)

full_name: instDistribMulActionUniformFun
code: instance {M : Type*} [Monoid M] [AddMonoid β] [DistribMulAction M β] :
    DistribMulAction M (α →ᵤ β) 
goal: DistribMulAction M (α →ᵤ β)

full_name: instDistribMulActionUniformOnFun
code: instance {M : Type*} [Monoid M] [AddMonoid β] [DistribMulAction M β] :
    DistribMulAction M (α →ᵤ[𝔖] β) 
goal: DistribMulAction M (α →ᵤ[𝔖] β)

full_name: instModuleUniformFun
code: instance [Semiring R] [AddCommMonoid β] [Module R β] : Module R (α →ᵤ β) 
goal: Module R (α →ᵤ β)

full_name: instModuleUniformOnFun
code: instance [Semiring R] [AddCommMonoid β] [Module R β] : Module R (α →ᵤ[𝔖] β) 
goal: Module R (α →ᵤ[𝔖] β)

full_name: instUniformAddGroupUniformFun
code: /-- If `G` is a uniform group, then `α →ᵤ G` is a uniform group as well. -/
@[to_additive "If `G` is a uniform additive group,
then `α →ᵤ G` is a uniform additive group as well."]
instance : UniformGroup (α →ᵤ G) 
goal: UniformAddGroup (α →ᵤ G)

full_name: instUniformGroupUniformFun
code: /-- If `G` is a uniform group, then `α →ᵤ G` is a uniform group as well. -/
@[to_additive "If `G` is a uniform additive group,
then `α →ᵤ G` is a uniform additive group as well."]
instance : UniformGroup (α →ᵤ G) 
goal: UniformGroup (α →ᵤ G)

full_name: UniformFun.hasBasis_nhds_zero_of_basis
code: @[to_additive]
protected theorem UniformFun.hasBasis_nhds_one_of_basis {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis p fun i => { f : α →ᵤ G | ∀ x, toFun f x ∈ b i } 
goal: (𝓝 0).HasBasis p fun i => {f | ∀ (x : α), UniformFun.toFun f x ∈ b i}

full_name: UniformFun.hasBasis_nhds_one_of_basis
code: @[to_additive]
protected theorem UniformFun.hasBasis_nhds_one_of_basis {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis p fun i => { f : α →ᵤ G | ∀ x, toFun f x ∈ b i } 
goal: (𝓝 1).HasBasis p fun i => {f | ∀ (x : α), UniformFun.toFun f x ∈ b i}

full_name: UniformFun.hasBasis_nhds_one
code: @[to_additive]
protected theorem UniformFun.hasBasis_nhds_one :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis (fun V : Set G => V ∈ (𝓝 1 : Filter G)) fun V =>
      { f : α → G | ∀ x, f x ∈ V } 
goal: (𝓝 1).HasBasis (fun V => V ∈ 𝓝 1) fun V => {f | ∀ (x : α), f x ∈ V}

full_name: UniformFun.hasBasis_nhds_zero
code: @[to_additive]
protected theorem UniformFun.hasBasis_nhds_one :
    (𝓝 1 : Filter (α →ᵤ G)).HasBasis (fun V : Set G => V ∈ (𝓝 1 : Filter G)) fun V =>
      { f : α → G | ∀ x, f x ∈ V } 
goal: (𝓝 0).HasBasis (fun V => V ∈ 𝓝 0) fun V => {f | ∀ (x : α), f x ∈ V}

full_name: instUniformAddGroupUniformOnFun
code: /-- Let `𝔖 : Set (Set α)`. If `G` is a uniform group, then `α →ᵤ[𝔖] G` is a uniform group as
well. -/
@[to_additive "Let `𝔖 : Set (Set α)`. If `G` is a uniform additive group,
then `α →ᵤ[𝔖] G` is a uniform additive group as well."]
instance : UniformGroup (α →ᵤ[𝔖] G) 
goal: UniformAddGroup (α →ᵤ[𝔖] G)

full_name: instUniformGroupUniformOnFun
code: /-- Let `𝔖 : Set (Set α)`. If `G` is a uniform group, then `α →ᵤ[𝔖] G` is a uniform group as
well. -/
@[to_additive "Let `𝔖 : Set (Set α)`. If `G` is a uniform additive group,
then `α →ᵤ[𝔖] G` is a uniform additive group as well."]
instance : UniformGroup (α →ᵤ[𝔖] G) 
goal: UniformGroup (α →ᵤ[𝔖] G)

full_name: UniformOnFun.hasBasis_nhds_zero_of_basis
code: @[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one_of_basis (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ Si.1, toFun 𝔖 f x ∈ b Si.2 } 
goal: (𝓝 0).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (UniformOnFun.toFun 𝔖) f x ∈ b Si.2}

full_name: UniformOnFun.hasBasis_nhds_one_of_basis
code: @[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one_of_basis (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) {p : ι → Prop} {b : ι → Set G}
    (h : (𝓝 1 : Filter G).HasBasis p b) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis (fun Si : Set α × ι => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ Si.1, toFun 𝔖 f x ∈ b Si.2 } 
goal: (𝓝 1).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p Si.2) fun Si => {f | ∀ x ∈ Si.1, (UniformOnFun.toFun 𝔖) f x ∈ b Si.2}

full_name: UniformOnFun.hasBasis_nhds_one
code: @[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis
      (fun SV : Set α × Set G => SV.1 ∈ 𝔖 ∧ SV.2 ∈ (𝓝 1 : Filter G)) fun SV =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ SV.1, f x ∈ SV.2 } 
goal: (𝓝 1).HasBasis (fun SV => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓝 1) fun SV => {f | ∀ x ∈ SV.1, f x ∈ SV.2}

full_name: UniformOnFun.hasBasis_nhds_zero
code: @[to_additive]
protected theorem UniformOnFun.hasBasis_nhds_one (𝔖 : Set <| Set α) (h𝔖₁ : 𝔖.Nonempty)
    (h𝔖₂ : DirectedOn (· ⊆ ·) 𝔖) :
    (𝓝 1 : Filter (α →ᵤ[𝔖] G)).HasBasis
      (fun SV : Set α × Set G => SV.1 ∈ 𝔖 ∧ SV.2 ∈ (𝓝 1 : Filter G)) fun SV =>
      { f : α →ᵤ[𝔖] G | ∀ x ∈ SV.1, f x ∈ SV.2 } 
goal: (𝓝 0).HasBasis (fun SV => SV.1 ∈ 𝔖 ∧ SV.2 ∈ 𝓝 0) fun SV => {f | ∀ x ∈ SV.1, f x ∈ SV.2}

full_name: UniformFun.uniformContinuousConstSMul
code: instance UniformFun.uniformContinuousConstSMul :
    UniformContinuousConstSMul M (α →ᵤ X) 
goal: UniformContinuousConstSMul M (α →ᵤ X)

full_name: UniformFunOn.uniformContinuousConstSMul
code: instance UniformFunOn.uniformContinuousConstSMul {𝔖 : Set (Set α)} :
    UniformContinuousConstSMul M (α →ᵤ[𝔖] X) 
goal: UniformContinuousConstSMul M (α →ᵤ[𝔖] X)