File: Mathlib/Topology/ContinuousFunction/CompactlySupported.lean

full_name: CompactlySupportedContinuousMap.hasCompactSupport'
code: /-- `C_c(α, β)` is the type of continuous functions `α → β` with compact support from a topological
space to a topological space with a zero element.

When possible, instead of parametrizing results over `f : C_c(α, β)`,
you should parametrize over `{F : Type*} [CompactlySupportedContinuousMapClass F α β] (f : F)`.

When you extend this structure, make sure to extend `CompactlySupportedContinuousMapClass`. -/
structure CompactlySupportedContinuousMap (α β : Type*) [TopologicalSpace α] [Zero β]
    [TopologicalSpace β] extends ContinuousMap α β where
  /-- The function has compact support . -/
  hasCompactSupport' : HasCompactSupport toFun
goal: HasCompactSupport self.toFun

full_name: CompactlySupportedContinuousMap
code: /-- `C_c(α, β)` is the type of continuous functions `α → β` with compact support from a topological
space to a topological space with a zero element.

When possible, instead of parametrizing results over `f : C_c(α, β)`,
you should parametrize over `{F : Type*} [CompactlySupportedContinuousMapClass F α β] (f : F)`.

When you extend this structure, make sure to extend `CompactlySupportedContinuousMapClass`. -/
structure CompactlySupportedContinuousMap (α β : Type*) [TopologicalSpace α] [Zero β]
    [TopologicalSpace β] extends ContinuousMap α β where
  /-- The function has compact support . -/
  hasCompactSupport' : HasCompactSupport toFun
goal: Type (max u_5 u_6)

full_name: CompactlySupported.«_aux_Mathlib_Topology_ContinuousFunction_CompactlySupported___macroRules_CompactlySupported_termC_c(_,_)_1»
code: @[inherit_doc]
scoped[CompactlySupported] notation (priority := 2000)
  "C_c(" α ", " β ")" => CompactlySupportedContinuousMap α β
goal: Lean.Macro

full_name: CompactlySupported._aux_Mathlib_Topology_ContinuousFunction_CompactlySupported___unexpand_CompactlySupportedContinuousMap_1
code: @[inherit_doc]
scoped[CompactlySupported] notation (priority := 2000)
  "C_c(" α ", " β ")" => CompactlySupportedContinuousMap α β
goal: Lean.PrettyPrinter.Unexpander

full_name: CompactlySupported.«_aux_Mathlib_Topology_ContinuousFunction_CompactlySupported___macroRules_CompactlySupported_term_→C_c__1»
code: @[inherit_doc]
scoped[CompactlySupported] notation α " →C_c " β => CompactlySupportedContinuousMap α β
goal: Lean.Macro

full_name: CompactlySupported._aux_Mathlib_Topology_ContinuousFunction_CompactlySupported___unexpand_CompactlySupportedContinuousMap_2
code: @[inherit_doc]
scoped[CompactlySupported] notation α " →C_c " β => CompactlySupportedContinuousMap α β
goal: Lean.PrettyPrinter.Unexpander

full_name: CompactlySupportedContinuousMapClass.hasCompactSupport
code: /-- `CompactlySupportedContinuousMapClass F α β` states that `F` is a type of continuous maps with
compact support.

You should also extend this typeclass when you extend `CompactlySupportedContinuousMap`. -/
class CompactlySupportedContinuousMapClass (F : Type*) (α β : outParam <| Type*)
    [TopologicalSpace α] [Zero β] [TopologicalSpace β] [FunLike F α β]
    extends ContinuousMapClass F α β : Prop where
  /-- Each member of the class has compact support. -/
  hasCompactSupport (f : F) : HasCompactSupport f
goal: HasCompactSupport ⇑f

full_name: CompactlySupportedContinuousMapClass
code: /-- `CompactlySupportedContinuousMapClass F α β` states that `F` is a type of continuous maps with
compact support.

You should also extend this typeclass when you extend `CompactlySupportedContinuousMap`. -/
class CompactlySupportedContinuousMapClass (F : Type*) (α β : outParam <| Type*)
    [TopologicalSpace α] [Zero β] [TopologicalSpace β] [FunLike F α β]
    extends ContinuousMapClass F α β : Prop where
  /-- Each member of the class has compact support. -/
  hasCompactSupport (f : F) : HasCompactSupport f
goal: Prop

full_name: CompactlySupportedContinuousMap.instFunLike
code: instance : FunLike C_c(α, β) α β 
goal: FunLike (α →C_c β) α β

full_name: CompactlySupportedContinuousMap.hasCompactSupport
code: protected lemma hasCompactSupport (f : C_c(α, β)) : HasCompactSupport f 
goal: HasCompactSupport ⇑f

full_name: CompactlySupportedContinuousMap.instCompactlySupportedContinuousMapClass
code: instance : CompactlySupportedContinuousMapClass C_c(α, β) α β 
goal: CompactlySupportedContinuousMapClass (α →C_c β) α β

full_name: CompactlySupportedContinuousMap.coe_toContinuousMap
code: @[simp]
theorem coe_toContinuousMap (f : C_c(α, β)) : (f.toContinuousMap : α → β) = f 
goal: ⇑f.toContinuousMap = ⇑f

full_name: CompactlySupportedContinuousMap.ext
code: @[ext]
theorem ext {f g : C_c(α, β)} (h : ∀ x, f x = g x) : f = g 
goal: f = g

full_name: CompactlySupportedContinuousMap.coe_mk
code: @[simp]
theorem coe_mk (f : C(α, β)) (h : HasCompactSupport f) : ⇑(⟨f, h⟩ : C_c(α, β)) = f 
goal: ⇑{ toContinuousMap := f, hasCompactSupport' := h } = ⇑f

full_name: CompactlySupportedContinuousMap.copy
code: /-- Copy of a `CompactlySupportedContinuousMap` with a new `toFun` equal to the old one. Useful
to fix definitional equalities. -/
protected def copy (f : C_c(α, β)) (f' : α → β) (h : f' = f) : C_c(α, β) 
goal: α →C_c β

full_name: CompactlySupportedContinuousMap.coe_copy
code: @[simp]
theorem coe_copy (f : C_c(α, β)) (f' : α → β) (h : f' = f) : ⇑(f.copy f' h) = f' 
goal: ⇑(f.copy f' h) = f'

full_name: CompactlySupportedContinuousMap.copy_eq
code: theorem copy_eq (f : C_c(α, β)) (f' : α → β) (h : f' = f) : f.copy f' h = f 
goal: f.copy f' h = f

full_name: CompactlySupportedContinuousMap.eq_of_empty
code: theorem eq_of_empty [IsEmpty α] (f g : C_c(α, β)) : f = g 
goal: f = g

full_name: CompactlySupportedContinuousMap.ContinuousMap.liftCompactlySupported_symm_apply
code: /-- A continuous function on a compact space automatically has compact support. -/
@[simps]
def ContinuousMap.liftCompactlySupported [CompactSpace α] : C(α, β) ≃ C_c(α, β) 
goal: CompactlySupportedContinuousMap.ContinuousMap.liftCompactlySupported.symm f = ↑f

full_name: CompactlySupportedContinuousMap.ContinuousMap.liftCompactlySupported_apply_toFun
code: /-- A continuous function on a compact space automatically has compact support. -/
@[simps]
def ContinuousMap.liftCompactlySupported [CompactSpace α] : C(α, β) ≃ C_c(α, β) 
goal: (CompactlySupportedContinuousMap.ContinuousMap.liftCompactlySupported f) a = f a

full_name: CompactlySupportedContinuousMap.ContinuousMap.liftCompactlySupported
code: /-- A continuous function on a compact space automatically has compact support. -/
@[simps]
def ContinuousMap.liftCompactlySupported [CompactSpace α] : C(α, β) ≃ C_c(α, β) 
goal: C(α, β) ≃ α →C_c β

full_name: CompactlySupportedContinuousMap.instZero
code: instance [Zero β] : Zero C_c(α, β) 
goal: Zero (α →C_c β)

full_name: CompactlySupportedContinuousMap.instInhabited
code: instance [Zero β] : Inhabited C_c(α, β) 
goal: Inhabited (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_zero
code: @[simp]
theorem coe_zero [Zero β] : ⇑(0 : C_c(α, β)) = 0 
goal: ⇑0 = 0

full_name: CompactlySupportedContinuousMap.zero_apply
code: theorem zero_apply [Zero β] : (0 : C_c(α, β)) x = 0 
goal: 0 x = 0

full_name: CompactlySupportedContinuousMap.instMulOfContinuousMul
code: instance [MulZeroClass β] [ContinuousMul β] : Mul C_c(α, β) 
goal: Mul (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_mul
code: @[simp]
theorem coe_mul [MulZeroClass β] [ContinuousMul β] (f g : C_c(α, β)) : ⇑(f * g) = f * g 
goal: ⇑(f * g) = ⇑f * ⇑g

full_name: CompactlySupportedContinuousMap.mul_apply
code: theorem mul_apply [MulZeroClass β] [ContinuousMul β] (f g : C_c(α, β)) : (f * g) x = f x * g x 
goal: (f * g) x = f x * g x

full_name: CompactlySupportedContinuousMap.instSMulOfContinuousSMulOfContinuousMapClass
code: /-- the product of `f : F` assuming `ContinuousMapClass F α γ` and `ContinuousSMul γ β` and
`g : C_c(α, β)` is in `C_c(α, β)` -/
instance [Zero β] [TopologicalSpace γ] [SMulZeroClass γ β] [ContinuousSMul γ β]
    {F : Type*} [FunLike F α γ] [ContinuousMapClass F α γ] : SMul F C_c(α, β) 
goal: SMul F (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_smulc
code: @[simp]
theorem coe_smulc [Zero β] [TopologicalSpace γ] [SMulZeroClass γ β] [ContinuousSMul γ β]
    {F : Type*} [FunLike F α γ] [ContinuousMapClass F α γ] (f : F) (g : C_c(α, β)) :
    ⇑(f • g) = fun x => f x • g x 
goal: ⇑(f • g) = fun x => f x • g x

full_name: CompactlySupportedContinuousMap.smulc_apply
code: theorem smulc_apply [Zero β] [TopologicalSpace γ] [SMulZeroClass γ β] [ContinuousSMul γ β]
    {F : Type*} [FunLike F α γ] [ContinuousMapClass F α γ] (f : F) (g : C_c(α, β)) (x : α) :
    (f • g) x = f x • g x 
goal: (f • g) x = f x • g x

full_name: CompactlySupportedContinuousMap.instMulZeroClassOfContinuousMul
code: instance [MulZeroClass β] [ContinuousMul β] : MulZeroClass C_c(α, β) 
goal: MulZeroClass (α →C_c β)

full_name: CompactlySupportedContinuousMap.instSemigroupWithZeroOfContinuousMul
code: instance [SemigroupWithZero β] [ContinuousMul β] :
    SemigroupWithZero C_c(α, β) 
goal: SemigroupWithZero (α →C_c β)

full_name: CompactlySupportedContinuousMap.instAddOfContinuousAdd
code: instance [AddZeroClass β] [ContinuousAdd β] : Add C_c(α, β) 
goal: Add (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_add
code: @[simp]
theorem coe_add [AddZeroClass β] [ContinuousAdd β] (f g : C_c(α, β)) : ⇑(f + g) = f + g 
goal: ⇑(f + g) = ⇑f + ⇑g

full_name: CompactlySupportedContinuousMap.add_apply
code: theorem add_apply [AddZeroClass β] [ContinuousAdd β] (f g : C_c(α, β)) : (f + g) x = f x + g x 
goal: (f + g) x = f x + g x

full_name: CompactlySupportedContinuousMap.instAddZeroClassOfContinuousAdd
code: instance [AddZeroClass β] [ContinuousAdd β] : AddZeroClass C_c(α, β) 
goal: AddZeroClass (α →C_c β)

full_name: CompactlySupportedContinuousMap.coeFnMonoidHom
code: /-- Coercion to a function as a `AddMonoidHom`. Similar to `AddMonoidHom.coeFn`. -/
def coeFnMonoidHom [AddMonoid β] [ContinuousAdd β] : C_c(α, β) →+ α → β 
goal: (α →C_c β) →+ α → β

full_name: CompactlySupportedContinuousMap.instSMulOfContinuousConstSMul
code: instance [Zero β] {R : Type*} [SMulZeroClass R β] [ContinuousConstSMul R β] :
    SMul R C_c(α, β) 
goal: SMul R (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_smul
code: @[simp, norm_cast]
theorem coe_smul [Zero β] {R : Type*} [SMulZeroClass R β] [ContinuousConstSMul R β] (r : R)
    (f : C_c(α, β)) : ⇑(r • f) = r • ⇑f 
goal: ⇑(r • f) = r • ⇑f

full_name: CompactlySupportedContinuousMap.smul_apply
code: theorem smul_apply [Zero β] {R : Type*} [SMulZeroClass R β] [ContinuousConstSMul R β] (r : R)
    (f : C_c(α, β)) (x : α) : (r • f) x = r • f x 
goal: (r • f) x = r • f x

full_name: CompactlySupportedContinuousMap.instAddMonoidOfContinuousAdd
code: instance [AddMonoid β] [ContinuousAdd β] : AddMonoid C_c(α, β) 
goal: AddMonoid (α →C_c β)

full_name: CompactlySupportedContinuousMap.instAddCommMonoidOfContinuousAdd
code: instance [AddCommMonoid β] [ContinuousAdd β] : AddCommMonoid C_c(α, β) 
goal: AddCommMonoid (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_sum
code: @[simp]
theorem coe_sum [AddCommMonoid β] [ContinuousAdd β] {ι : Type*} (s : Finset ι) (f : ι → C_c(α, β)) :
    ⇑(∑ i in s, f i) = ∑ i in s, (f i : α → β) 
goal: ⇑(∑ i ∈ s, f i) = ∑ i ∈ s, ⇑(f i)

full_name: CompactlySupportedContinuousMap.sum_apply
code: theorem sum_apply [AddCommMonoid β] [ContinuousAdd β] {ι : Type*} (s : Finset ι) (f : ι → C_c(α, β))
    (a : α) : (∑ i in s, f i) a = ∑ i in s, f i a 
goal: (∑ i ∈ s, f i) a = ∑ i ∈ s, (f i) a

full_name: CompactlySupportedContinuousMap.instNeg
code: instance : Neg C_c(α, β) 
goal: Neg (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_neg
code: @[simp]
theorem coe_neg : ⇑(-f) = -f 
goal: ⇑(-f) = -⇑f

full_name: CompactlySupportedContinuousMap.neg_apply
code: theorem neg_apply : (-f) x = -f x 
goal: (-f) x = -f x

full_name: CompactlySupportedContinuousMap.instSub
code: instance : Sub C_c(α, β) 
goal: Sub (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_sub
code: @[simp]
theorem coe_sub : ⇑(f - g) = f - g 
goal: ⇑(f - g) = ⇑f - ⇑g

full_name: CompactlySupportedContinuousMap.sub_apply
code: theorem sub_apply : (f - g) x = f x - g x 
goal: (f - g) x = f x - g x

full_name: CompactlySupportedContinuousMap.instAddGroup
code: instance : AddGroup C_c(α, β) 
goal: AddGroup (α →C_c β)

full_name: CompactlySupportedContinuousMap.instAddCommGroupOfTopologicalAddGroup
code: instance [AddCommGroup β] [TopologicalAddGroup β] : AddCommGroup C_c(α, β) 
goal: AddCommGroup (α →C_c β)

full_name: CompactlySupportedContinuousMap.instIsCentralScalar
code: instance [Zero β] {R : Type*} [Zero R] [SMulWithZero R β] [SMulWithZero Rᵐᵒᵖ β]
    [ContinuousConstSMul R β] [IsCentralScalar R β] : IsCentralScalar R C_c(α, β) 
goal: IsCentralScalar R (α →C_c β)

full_name: CompactlySupportedContinuousMap.instSMulWithZeroOfContinuousConstSMul
code: instance [Zero β] {R : Type*} [Zero R] [SMulWithZero R β]
    [ContinuousConstSMul R β] : SMulWithZero R C_c(α, β) 
goal: SMulWithZero R (α →C_c β)

full_name: CompactlySupportedContinuousMap.instMulActionWithZeroOfContinuousConstSMul
code: instance [Zero β] {R : Type*} [MonoidWithZero R] [MulActionWithZero R β]
    [ContinuousConstSMul R β] : MulActionWithZero R C_c(α, β) 
goal: MulActionWithZero R (α →C_c β)

full_name: CompactlySupportedContinuousMap.instModuleOfContinuousConstSMul
code: instance [AddCommMonoid β] [ContinuousAdd β] {R : Type*} [Semiring R] [Module R β]
    [ContinuousConstSMul R β] : Module R C_c(α, β) 
goal: Module R (α →C_c β)

full_name: CompactlySupportedContinuousMap.instNonUnitalNonAssocSemiringOfTopologicalSemiring
code: instance [NonUnitalNonAssocSemiring β] [TopologicalSemiring β] :
    NonUnitalNonAssocSemiring C_c(α, β) 
goal: NonUnitalNonAssocSemiring (α →C_c β)

full_name: CompactlySupportedContinuousMap.instNonUnitalSemiringOfTopologicalSemiring
code: instance [NonUnitalSemiring β] [TopologicalSemiring β] :
    NonUnitalSemiring C_c(α, β) 
goal: NonUnitalSemiring (α →C_c β)

full_name: CompactlySupportedContinuousMap.instNonUnitalCommSemiringOfTopologicalSemiring
code: instance [NonUnitalCommSemiring β] [TopologicalSemiring β] :
    NonUnitalCommSemiring C_c(α, β) 
goal: NonUnitalCommSemiring (α →C_c β)

full_name: CompactlySupportedContinuousMap.instNonUnitalNonAssocRingOfTopologicalRing
code: instance [NonUnitalNonAssocRing β] [TopologicalRing β] :
    NonUnitalNonAssocRing C_c(α, β) 
goal: NonUnitalNonAssocRing (α →C_c β)

full_name: CompactlySupportedContinuousMap.instNonUnitalRingOfTopologicalRing
code: instance [NonUnitalRing β] [TopologicalRing β] : NonUnitalRing C_c(α, β) 
goal: NonUnitalRing (α →C_c β)

full_name: CompactlySupportedContinuousMap.instNonUnitalCommRingOfTopologicalRing
code: instance [NonUnitalCommRing β] [TopologicalRing β] :
    NonUnitalCommRing C_c(α, β) 
goal: NonUnitalCommRing (α →C_c β)

full_name: CompactlySupportedContinuousMap.instIsScalarTower
code: instance {R : Type*} [Semiring R] [NonUnitalNonAssocSemiring β]
    [TopologicalSemiring β] [Module R β] [ContinuousConstSMul R β] [IsScalarTower R β β] :
    IsScalarTower R C_c(α, β) C_c(α, β) 
goal: IsScalarTower R (α →C_c β) (α →C_c β)

full_name: CompactlySupportedContinuousMap.instSMulCommClass
code: instance {R : Type*} [Semiring R] [NonUnitalNonAssocSemiring β]
    [TopologicalSemiring β] [Module R β] [ContinuousConstSMul R β] [SMulCommClass R β β] :
    SMulCommClass R C_c(α, β) C_c(α, β) 
goal: SMulCommClass R (α →C_c β) (α →C_c β)

full_name: CompactlySupportedContinuousMap.instStar
code: instance : Star C_c(α, β) 
goal: Star (α →C_c β)

full_name: CompactlySupportedContinuousMap.coe_star
code: @[simp]
theorem coe_star (f : C_c(α, β)) : ⇑(star f) = star (⇑f) 
goal: ⇑(star f) = star ⇑f

full_name: CompactlySupportedContinuousMap.star_apply
code: theorem star_apply (f : C_c(α, β)) (x : α) : (star f) x = star (f x) 
goal: (star f) x = star (f x)

full_name: CompactlySupportedContinuousMap.instTrivialStar
code: instance [TrivialStar β] : TrivialStar C_c(α, β) 
goal: TrivialStar (α →C_c β)

full_name: CompactlySupportedContinuousMap.instStarAddMonoid
code: instance [ContinuousAdd β] : StarAddMonoid C_c(α, β) 
goal: StarAddMonoid (α →C_c β)

full_name: CompactlySupportedContinuousMap.instStarModule
code: instance : StarModule 𝕜 C_c(α, β) 
goal: StarModule 𝕜 (α →C_c β)

full_name: CompactlySupportedContinuousMap.instStarRing
code: instance : StarRing C_c(α, β) 
goal: StarRing (α →C_c β)

full_name: CompactlySupportedContinuousMap.«_aux_Mathlib_Topology_ContinuousFunction_CompactlySupported___macroRules_CompactlySupportedContinuousMap_term_→co__1»
code: local notation α " →co " β => CocompactMap α β
goal: Lean.Macro

full_name: CompactlySupportedContinuousMap._aux_Mathlib_Topology_ContinuousFunction_CompactlySupported___unexpand_CocompactMap_1
code: local notation α " →co " β => CocompactMap α β
goal: Lean.PrettyPrinter.Unexpander

full_name: CompactlySupportedContinuousMap.comp
code: /-- Composition of a continuous function with compact support with a cocompact map
yields another continuous function with compact support. -/
def comp (f : C_c(γ, δ)) (g : β →co γ) : C_c(β, δ) 
goal: β →C_c δ

full_name: CompactlySupportedContinuousMap.coe_comp_to_continuous_fun
code: @[simp]
theorem coe_comp_to_continuous_fun (f : C_c(γ, δ)) (g : β →co γ) : ((f.comp g) : β → δ) = f ∘ g 
goal: ⇑(f.comp g) = ⇑f ∘ ⇑g

full_name: CompactlySupportedContinuousMap.comp_id
code: @[simp]
theorem comp_id (f : C_c(γ, δ)) : f.comp (CocompactMap.id γ) = f 
goal: f.comp (CocompactMap.id γ) = f

full_name: CompactlySupportedContinuousMap.comp_assoc
code: @[simp]
theorem comp_assoc (f : C_c(γ, δ)) (g : β →co γ) (h : α →co β) :
    (f.comp g).comp h = f.comp (g.comp h) 
goal: (f.comp g).comp h = f.comp (g.comp h)

full_name: CompactlySupportedContinuousMap.zero_comp
code: @[simp]
theorem zero_comp (g : β →co γ) : (0 : C_c(γ, δ)).comp g = 0 
goal: CompactlySupportedContinuousMap.comp 0 g = 0

full_name: CompactlySupportedContinuousMap.compAddMonoidHom
code: /-- Composition as an additive monoid homomorphism. -/
def compAddMonoidHom [AddMonoid δ] [ContinuousAdd δ] (g : β →co γ) : C_c(γ, δ) →+ C_c(β, δ) 
goal: (γ →C_c δ) →+ β →C_c δ

full_name: CompactlySupportedContinuousMap.compMulHom
code: /-- Composition as a semigroup homomorphism. -/
def compMulHom [MulZeroClass δ] [ContinuousMul δ] (g : β →co γ) : C_c(γ, δ) →ₙ* C_c(β, δ) 
goal: (γ →C_c δ) →ₙ* β →C_c δ

full_name: CompactlySupportedContinuousMap.compLinearMap
code: /-- Composition as a linear map. -/
def compLinearMap [AddCommMonoid δ] [ContinuousAdd δ] {R : Type*} [Semiring R] [Module R δ]
    [ContinuousConstSMul R δ] (g : β →co γ) : C_c(γ, δ) →ₗ[R] C_c(β, δ) 
goal: (γ →C_c δ) →ₗ[R] β →C_c δ

full_name: CompactlySupportedContinuousMap.compNonUnitalAlgHom
code: /-- Composition as a non-unital algebra homomorphism. -/
def compNonUnitalAlgHom {R : Type*} [Semiring R] [NonUnitalNonAssocSemiring δ]
    [TopologicalSemiring δ] [Module R δ] [ContinuousConstSMul R δ] (g : β →co γ) :
    C_c(γ, δ) →ₙₐ[R] C_c(β, δ) 
goal: (γ →C_c δ) →ₙₐ[R] β →C_c δ

full_name: CompactlySupportedContinuousMapClass.instCoeTCCompactlySupportedContinuousMap
code: instance : CoeTC F (CompactlySupportedContinuousMap α β) 
goal: CoeTC F (α →C_c β)

full_name: CompactlySupportedContinuousMapClass.of_compactSpace
code: /-- A continuous function on a compact space has automatically compact support. This is not an
instance to avoid type class loops. -/
lemma of_compactSpace (G : Type*) [FunLike G α β]
    [ContinuousMapClass G α β] [CompactSpace α] : CompactlySupportedContinuousMapClass G α β 
goal: CompactlySupportedContinuousMapClass G α β

full_name: CompactlySupportedContinuousMapClass.uniformContinuous
code: theorem uniformContinuous (f : F) : UniformContinuous (f : β → γ) 
goal: UniformContinuous ⇑f

full_name: CompactlySupportedContinuousMapClass.instZeroAtInftyContinuousMapClass
code: instance : ZeroAtInftyContinuousMapClass F β γ 
goal: ZeroAtInftyContinuousMapClass F β γ