File: Mathlib/Analysis/CstarAlgebra/ContinuousFunctionalCalculus/Unique.lean

full_name: RCLike.uniqueContinuousFunctionalCalculus_of_compactSpace_spectrum
code: theorem RCLike.uniqueContinuousFunctionalCalculus_of_compactSpace_spectrum [TopologicalSpace A]
    [T2Space A] [Ring A] [StarRing A] [Algebra 𝕜 A] [h : ∀ a : A, CompactSpace (spectrum 𝕜 a)] :
    UniqueContinuousFunctionalCalculus 𝕜 A 
goal: UniqueContinuousFunctionalCalculus 𝕜 A

full_name: RCLike.instUniqueContinuousFunctionalCalculus
code: instance RCLike.instUniqueContinuousFunctionalCalculus [NormedRing A] [StarRing A]
    [NormedAlgebra 𝕜 A] [CompleteSpace A] : UniqueContinuousFunctionalCalculus 𝕜 A 
goal: UniqueContinuousFunctionalCalculus 𝕜 A

full_name: ContinuousMap.toNNReal
code: /-- This map sends `f : C(X, ℝ)` to `Real.toNNReal ∘ f`, bundled as a continuous map `C(X, ℝ≥0)`. -/
noncomputable def toNNReal (f : C(X, ℝ)) : C(X, ℝ≥0) 
goal: C(X, NNReal)

full_name: ContinuousMap.continuous_toNNReal
code: @[fun_prop]
lemma continuous_toNNReal : Continuous (toNNReal (X := X)) 
goal: Continuous ContinuousMap.toNNReal

full_name: ContinuousMap.toNNReal_apply
code: @[simp]
lemma toNNReal_apply (f : C(X, ℝ)) (x : X) : f.toNNReal x = (f x).toNNReal 
goal: f.toNNReal x = (f x).toNNReal

full_name: ContinuousMap.toNNReal_add_add_neg_add_neg_eq
code: lemma toNNReal_add_add_neg_add_neg_eq (f g : C(X, ℝ)) :
    (f + g).toNNReal + (-f).toNNReal + (-g).toNNReal =
      (-(f + g)).toNNReal + f.toNNReal + g.toNNReal 
goal: (f + g).toNNReal + (-f).toNNReal + (-g).toNNReal = (-(f + g)).toNNReal + f.toNNReal + g.toNNReal

full_name: ContinuousMap.toNNReal_mul_add_neg_mul_add_mul_neg_eq
code: lemma toNNReal_mul_add_neg_mul_add_mul_neg_eq (f g : C(X, ℝ)) :
    (f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal =
      (-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal 
goal: (f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal =
  (-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal

full_name: ContinuousMap.toNNReal_algebraMap
code: @[simp]
lemma toNNReal_algebraMap (r : ℝ≥0) :
    (algebraMap ℝ C(X, ℝ) r).toNNReal = algebraMap ℝ≥0 C(X, ℝ≥0) r 
goal: ((algebraMap ℝ C(X, ℝ)) ↑r).toNNReal = (algebraMap NNReal C(X, NNReal)) r

full_name: ContinuousMap.toNNReal_neg_algebraMap
code: @[simp]
lemma toNNReal_neg_algebraMap (r : ℝ≥0) : (- algebraMap ℝ C(X, ℝ) r).toNNReal = 0 
goal: (-(algebraMap ℝ C(X, ℝ)) ↑r).toNNReal = 0

full_name: ContinuousMap.toNNReal_one
code: @[simp]
lemma toNNReal_one : (1 : C(X, ℝ)).toNNReal = 1 
goal: ContinuousMap.toNNReal 1 = 1

full_name: ContinuousMap.toNNReal_neg_one
code: @[simp]
lemma toNNReal_neg_one : (-1 : C(X, ℝ)).toNNReal = 0 
goal: (-1).toNNReal = 0

full_name: StarAlgHom.realContinuousMapOfNNReal_apply
code: /-- Given a star `ℝ≥0`-algebra homomorphism `φ` from `C(X, ℝ≥0)` into an `ℝ`-algebra `A`, this is
the unique extension of `φ` from `C(X, ℝ)` to `A` as a star `ℝ`-algebra homomorphism. -/
@[simps]
noncomputable def realContinuousMapOfNNReal (φ : C(X, ℝ≥0) →⋆ₐ[ℝ≥0] A) :
    C(X, ℝ) →⋆ₐ[ℝ] A 
goal: φ.realContinuousMapOfNNReal f = φ f.toNNReal - φ (-f).toNNReal

full_name: StarAlgHom.realContinuousMapOfNNReal
code: /-- Given a star `ℝ≥0`-algebra homomorphism `φ` from `C(X, ℝ≥0)` into an `ℝ`-algebra `A`, this is
the unique extension of `φ` from `C(X, ℝ)` to `A` as a star `ℝ`-algebra homomorphism. -/
@[simps]
noncomputable def realContinuousMapOfNNReal (φ : C(X, ℝ≥0) →⋆ₐ[ℝ≥0] A) :
    C(X, ℝ) →⋆ₐ[ℝ] A 
goal: C(X, ℝ) →⋆ₐ[ℝ] A

full_name: StarAlgHom.continuous_realContinuousMapOfNNReal
code: @[fun_prop]
lemma continuous_realContinuousMapOfNNReal (φ : C(X, ℝ≥0) →⋆ₐ[ℝ≥0] A)
    (hφ : Continuous φ) : Continuous φ.realContinuousMapOfNNReal 
goal: Continuous ⇑φ.realContinuousMapOfNNReal

full_name: StarAlgHom.realContinuousMapOfNNReal_apply_comp_toReal
code: @[simp high]
lemma realContinuousMapOfNNReal_apply_comp_toReal (φ : C(X, ℝ≥0) →⋆ₐ[ℝ≥0] A)
    (f : C(X, ℝ≥0)) :
    φ.realContinuousMapOfNNReal ((ContinuousMap.mk toReal continuous_coe).comp f) = φ f 
goal: φ.realContinuousMapOfNNReal ({ toFun := NNReal.toReal, continuous_toFun := NNReal.continuous_coe }.comp f) = φ f

full_name: StarAlgHom.realContinuousMapOfNNReal_injective
code: lemma realContinuousMapOfNNReal_injective :
    Function.Injective (realContinuousMapOfNNReal (X := X) (A := A)) 
goal: Function.Injective StarAlgHom.realContinuousMapOfNNReal

full_name: NNReal.instUniqueContinuousFunctionalCalculus
code: instance NNReal.instUniqueContinuousFunctionalCalculus [UniqueContinuousFunctionalCalculus ℝ A] :
    UniqueContinuousFunctionalCalculus ℝ≥0 A 
goal: UniqueContinuousFunctionalCalculus NNReal A

full_name: RCLike.uniqueNonUnitalContinuousFunctionalCalculus_of_compactSpace_quasispectrum
code: theorem RCLike.uniqueNonUnitalContinuousFunctionalCalculus_of_compactSpace_quasispectrum
    [TopologicalSpace A] [T2Space A] [NonUnitalRing A] [StarRing A] [Module 𝕜 A]
    [IsScalarTower 𝕜 A A] [SMulCommClass 𝕜 A A] [h : ∀ a : A, CompactSpace (quasispectrum 𝕜 a)] :
    UniqueNonUnitalContinuousFunctionalCalculus 𝕜 A 
goal: UniqueNonUnitalContinuousFunctionalCalculus 𝕜 A

full_name: RCLike.instUniqueNonUnitalContinuousFunctionalCalculus
code: instance RCLike.instUniqueNonUnitalContinuousFunctionalCalculus [NonUnitalNormedRing A]
    [StarRing A] [CompleteSpace A] [NormedSpace 𝕜 A] [IsScalarTower 𝕜 A A] [SMulCommClass 𝕜 A A] :
    UniqueNonUnitalContinuousFunctionalCalculus 𝕜 A 
goal: UniqueNonUnitalContinuousFunctionalCalculus 𝕜 A

full_name: ContinuousMapZero.toNNReal
code: /-- This map sends `f : C(X, ℝ)` to `Real.toNNReal ∘ f`, bundled as a continuous map `C(X, ℝ≥0)`. -/
noncomputable def toNNReal (f : C(X, ℝ)₀) : C(X, ℝ≥0)₀ 
goal: ContinuousMapZero X NNReal

full_name: ContinuousMapZero.toNNReal_apply
code: @[simp]
lemma toNNReal_apply (f : C(X, ℝ)₀) (x : X) : f.toNNReal x = Real.toNNReal (f x) 
goal: f.toNNReal x = (f x).toNNReal

full_name: ContinuousMapZero.continuous_toNNReal
code: @[fun_prop]
lemma continuous_toNNReal : Continuous (toNNReal (X := X)) 
goal: Continuous ContinuousMapZero.toNNReal

full_name: ContinuousMapZero.toContinuousMapHom_toNNReal
code: lemma toContinuousMapHom_toNNReal (f : C(X, ℝ)₀) :
    (toContinuousMapHom (X := X) (R := ℝ) f).toNNReal =
      toContinuousMapHom (X := X) (R := ℝ≥0) f.toNNReal 
goal: (ContinuousMapZero.toContinuousMapHom f).toNNReal = ContinuousMapZero.toContinuousMapHom f.toNNReal

full_name: ContinuousMapZero.toNNReal_smul
code: @[simp]
lemma toNNReal_smul (r : ℝ≥0) (f : C(X, ℝ)₀) : (r • f).toNNReal = r • f.toNNReal 
goal: (r • f).toNNReal = r • f.toNNReal

full_name: ContinuousMapZero.toNNReal_neg_smul
code: @[simp]
lemma toNNReal_neg_smul (r : ℝ≥0) (f : C(X, ℝ)₀) : (-(r • f)).toNNReal = r • (-f).toNNReal 
goal: (-(r • f)).toNNReal = r • (-f).toNNReal

full_name: ContinuousMapZero.toNNReal_mul_add_neg_mul_add_mul_neg_eq
code: lemma toNNReal_mul_add_neg_mul_add_mul_neg_eq (f g : C(X, ℝ)₀) :
    ((f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal) =
    ((-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal) 
goal: (f * g).toNNReal + (-f).toNNReal * g.toNNReal + f.toNNReal * (-g).toNNReal =
  (-(f * g)).toNNReal + f.toNNReal * g.toNNReal + (-f).toNNReal * (-g).toNNReal

full_name: ContinuousMapZero.toNNReal_add_add_neg_add_neg_eq
code: lemma toNNReal_add_add_neg_add_neg_eq (f g : C(X, ℝ)₀) :
    ((f + g).toNNReal + (-f).toNNReal + (-g).toNNReal) =
      ((-(f + g)).toNNReal + f.toNNReal + g.toNNReal) 
goal: (f + g).toNNReal + (-f).toNNReal + (-g).toNNReal = (-(f + g)).toNNReal + f.toNNReal + g.toNNReal

full_name: NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal
code: /-- Given a non-unital star `ℝ≥0`-algebra homomorphism `φ` from `C(X, ℝ≥0)₀` into a non-unital
`ℝ`-algebra `A`, this is the unique extension of `φ` from `C(X, ℝ)₀` to `A` as a non-unital
star `ℝ`-algebra homomorphism. -/
@[simps]
noncomputable def realContinuousMapZeroOfNNReal (φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A) :
    C(X, ℝ)₀ →⋆ₙₐ[ℝ] A 
goal: ContinuousMapZero X ℝ →⋆ₙₐ[ℝ] A

full_name: NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal_apply
code: /-- Given a non-unital star `ℝ≥0`-algebra homomorphism `φ` from `C(X, ℝ≥0)₀` into a non-unital
`ℝ`-algebra `A`, this is the unique extension of `φ` from `C(X, ℝ)₀` to `A` as a non-unital
star `ℝ`-algebra homomorphism. -/
@[simps]
noncomputable def realContinuousMapZeroOfNNReal (φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A) :
    C(X, ℝ)₀ →⋆ₙₐ[ℝ] A 
goal: φ.realContinuousMapZeroOfNNReal f = φ f.toNNReal - φ (-f).toNNReal

full_name: NonUnitalStarAlgHom.continuous_realContinuousMapZeroOfNNReal
code: @[fun_prop]
lemma continuous_realContinuousMapZeroOfNNReal (φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A)
    (hφ : Continuous φ) : Continuous φ.realContinuousMapZeroOfNNReal 
goal: Continuous ⇑φ.realContinuousMapZeroOfNNReal

full_name: NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal_apply_comp_toReal
code: @[simp high]
lemma realContinuousMapZeroOfNNReal_apply_comp_toReal (φ : C(X, ℝ≥0)₀ →⋆ₙₐ[ℝ≥0] A)
    (f : C(X, ℝ≥0)₀) :
    φ.realContinuousMapZeroOfNNReal ((ContinuousMapZero.mk ⟨toReal, continuous_coe⟩ rfl).comp f) =
      φ f 
goal: φ.realContinuousMapZeroOfNNReal
    ({ toFun := NNReal.toReal, continuous_toFun := NNReal.continuous_coe, map_zero' := ⋯ }.comp f) =
  φ f

full_name: NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal_injective
code: lemma realContinuousMapZeroOfNNReal_injective :
    Function.Injective (realContinuousMapZeroOfNNReal (X := X) (A := A)) 
goal: Function.Injective NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal

full_name: NNReal.instUniqueNonUnitalContinuousFunctionalCalculus
code: instance NNReal.instUniqueNonUnitalContinuousFunctionalCalculus
    [UniqueNonUnitalContinuousFunctionalCalculus ℝ A] :
    UniqueNonUnitalContinuousFunctionalCalculus ℝ≥0 A 
goal: UniqueNonUnitalContinuousFunctionalCalculus NNReal A