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

full_name: _aux_Mathlib_Analysis_CstarAlgebra_ContinuousFunctionalCalculus_Instances___macroRules_termσₙ_1
code: local notation "σₙ" => quasispectrum
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_CstarAlgebra_ContinuousFunctionalCalculus_Instances___unexpand_quasispectrum_1
code: local notation "σₙ" => quasispectrum
goal: Lean.PrettyPrinter.Unexpander

full_name: _aux_Mathlib_Analysis_CstarAlgebra_ContinuousFunctionalCalculus_Instances___macroRules_termσ_1
code: local notation "σ" => spectrum
goal: Lean.Macro

full_name: _aux_Mathlib_Analysis_CstarAlgebra_ContinuousFunctionalCalculus_Instances___unexpand_spectrum_1
code: local notation "σ" => spectrum
goal: Lean.PrettyPrinter.Unexpander

full_name: «_aux_Mathlib_Analysis_CstarAlgebra_ContinuousFunctionalCalculus_Instances___macroRules_term_⁺¹_1»
code: local postfix:max "⁺¹" => Unitization 𝕜
goal: Lean.Macro

full_name: cfcₙAux
code: /--
This is an auxiliary definition used for constructing an instance of the non-unital continuous
functional calculus given a instance of the unital one on the unitization.

This is the natural non-unital star homomorphism obtained from the chain
```lean
calc
  C(σₙ 𝕜 a, 𝕜)₀ →⋆ₙₐ[𝕜] C(σₙ 𝕜 a, 𝕜) := ContinuousMapZero.toContinuousMapHom
  _             ≃⋆[𝕜] C(σ 𝕜 (↑a : A⁺¹), 𝕜) := Homeomorph.compStarAlgEquiv'
  _             →⋆ₐ[𝕜] A⁺¹ := cfcHom
```
This range of this map is contained in the range of `(↑) : A → A⁺¹` (see `cfcₙAux_mem_range_inr`),
and so we may restrict it to `A` to get the necessary homomorphism for the non-unital continuous
functional calculus.
-/
noncomputable def cfcₙAux : C(σₙ 𝕜 a, 𝕜)₀ →⋆ₙₐ[𝕜] A⁺¹ 
goal: ContinuousMapZero (↑(quasispectrum 𝕜 a)) 𝕜 →⋆ₙₐ[𝕜] Unitization 𝕜 A

full_name: cfcₙAux_id
code: lemma cfcₙAux_id : cfcₙAux hp₁ a ha (ContinuousMapZero.id rfl) = a 
goal: (cfcₙAux ⋯ a ha) (ContinuousMapZero.id ⋯) = ↑a

full_name: closedEmbedding_cfcₙAux
code: lemma closedEmbedding_cfcₙAux : ClosedEmbedding (cfcₙAux hp₁ a ha) 
goal: ClosedEmbedding ⇑(cfcₙAux ⋯ a ha)

full_name: spec_cfcₙAux
code: lemma spec_cfcₙAux (f : C(σₙ 𝕜 a, 𝕜)₀) : σ 𝕜 (cfcₙAux hp₁ a ha f) = Set.range f 
goal: spectrum 𝕜 ((cfcₙAux ⋯ a ha) f) = Set.range ⇑f

full_name: cfcₙAux_mem_range_inr
code: lemma cfcₙAux_mem_range_inr (f : C(σₙ 𝕜 a, 𝕜)₀) :
    cfcₙAux hp₁ a ha f ∈ NonUnitalStarAlgHom.range (Unitization.inrNonUnitalStarAlgHom 𝕜 A) 
goal: (cfcₙAux ⋯ a ha) f ∈ NonUnitalStarAlgHom.range (Unitization.inrNonUnitalStarAlgHom 𝕜 A)

full_name: RCLike.nonUnitalContinuousFunctionalCalculus
code: theorem RCLike.nonUnitalContinuousFunctionalCalculus :
    NonUnitalContinuousFunctionalCalculus 𝕜 (p : A → Prop) 
goal: NonUnitalContinuousFunctionalCalculus 𝕜 p

full_name: IsStarNormal.instContinuousFunctionalCalculus
code: instance IsStarNormal.instContinuousFunctionalCalculus {A : Type*} [NormedRing A] [StarRing A]
    [CstarRing A] [CompleteSpace A] [NormedAlgebra ℂ A] [StarModule ℂ A] :
    ContinuousFunctionalCalculus ℂ (IsStarNormal : A → Prop) 
goal: ContinuousFunctionalCalculus ℂ IsStarNormal

full_name: IsStarNormal.instNonUnitalContinuousFunctionalCalculus
code: instance IsStarNormal.instNonUnitalContinuousFunctionalCalculus {A : Type*} [NonUnitalNormedRing A]
    [StarRing A] [CstarRing A] [CompleteSpace A] [NormedSpace ℂ A] [IsScalarTower ℂ A A]
    [SMulCommClass ℂ A A] [StarModule ℂ A] :
    NonUnitalContinuousFunctionalCalculus ℂ (IsStarNormal : A → Prop) 
goal: NonUnitalContinuousFunctionalCalculus ℂ IsStarNormal

full_name: IsStarNormal.cfcₙ_map
code: instance IsStarNormal.cfcₙ_map {R A : Type*} {p : A → Prop} [CommSemiring R] [StarRing R]
    [MetricSpace R] [TopologicalSemiring R] [ContinuousStar R] [Nontrivial R] [TopologicalSpace A]
    [NonUnitalRing A] [StarRing A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A]
    [NonUnitalContinuousFunctionalCalculus R p] (a : A) (f : R → R) :
    IsStarNormal (cfcₙ f a) 
goal: IsStarNormal (cfcₙ f a)

full_name: IsStarNormal.cfc_map
code: instance IsStarNormal.cfc_map {R A : Type*} {p : A → Prop} [CommSemiring R] [StarRing R]
    [MetricSpace R] [TopologicalSemiring R] [ContinuousStar R] [TopologicalSpace A] [Ring A]
    [StarRing A] [Algebra R A] [ContinuousFunctionalCalculus R p] (a : A) (f : R → R) :
    IsStarNormal (cfc f a) 
goal: IsStarNormal (cfc f a)

full_name: isSelfAdjoint_iff_isStarNormal_and_quasispectrumRestricts
code: /-- An element in a non-unital C⋆-algebra is selfadjoint if and only if it is normal and its
quasispectrum is contained in `ℝ`. -/
lemma isSelfAdjoint_iff_isStarNormal_and_quasispectrumRestricts {a : A} :
    IsSelfAdjoint a ↔ IsStarNormal a ∧ QuasispectrumRestricts a Complex.reCLM 
goal: IsSelfAdjoint a ↔ IsStarNormal a ∧ QuasispectrumRestricts a ⇑Complex.reCLM

full_name: QuasispectrumRestricts.isSelfAdjoint
code: /-- A normal element whose `ℂ`-quasispectrum is contained in `ℝ` is selfadjoint. -/
lemma QuasispectrumRestricts.isSelfAdjoint (a : A) (ha : QuasispectrumRestricts a Complex.reCLM)
    [IsStarNormal a] : IsSelfAdjoint a 
goal: IsSelfAdjoint a

full_name: IsSelfAdjoint.instNonUnitalContinuousFunctionalCalculus
code: instance IsSelfAdjoint.instNonUnitalContinuousFunctionalCalculus
    [∀ x : A, CompactSpace (σₙ ℂ x)] :
    NonUnitalContinuousFunctionalCalculus ℝ (IsSelfAdjoint : A → Prop) 
goal: NonUnitalContinuousFunctionalCalculus ℝ IsSelfAdjoint

full_name: isSelfAdjoint_iff_isStarNormal_and_spectrumRestricts
code: /-- An element in a C⋆-algebra is selfadjoint if and only if it is normal and its spectrum is
contained in `ℝ`. -/
lemma isSelfAdjoint_iff_isStarNormal_and_spectrumRestricts {a : A} :
    IsSelfAdjoint a ↔ IsStarNormal a ∧ SpectrumRestricts a Complex.reCLM 
goal: IsSelfAdjoint a ↔ IsStarNormal a ∧ SpectrumRestricts a ⇑Complex.reCLM

full_name: IsSelfAdjoint.spectrumRestricts
code: lemma IsSelfAdjoint.spectrumRestricts {a : A} (ha : IsSelfAdjoint a) :
    SpectrumRestricts a Complex.reCLM 
goal: SpectrumRestricts a ⇑Complex.reCLM

full_name: SpectrumRestricts.isSelfAdjoint
code: /-- A normal element whose `ℂ`-spectrum is contained in `ℝ` is selfadjoint. -/
lemma SpectrumRestricts.isSelfAdjoint (a : A) (ha : SpectrumRestricts a Complex.reCLM)
    [IsStarNormal a] : IsSelfAdjoint a 
goal: IsSelfAdjoint a

full_name: IsSelfAdjoint.instContinuousFunctionalCalculus
code: instance IsSelfAdjoint.instContinuousFunctionalCalculus [∀ x : A, CompactSpace (spectrum ℂ x)] :
    ContinuousFunctionalCalculus ℝ (IsSelfAdjoint : A → Prop) 
goal: ContinuousFunctionalCalculus ℝ IsSelfAdjoint

full_name: CFC.exists_sqrt_of_isSelfAdjoint_of_quasispectrumRestricts
code: lemma CFC.exists_sqrt_of_isSelfAdjoint_of_quasispectrumRestricts {A : Type*} [NonUnitalRing A]
    [StarRing A] [TopologicalSpace A] [Module ℝ A] [IsScalarTower ℝ A A] [SMulCommClass ℝ A A ]
    [NonUnitalContinuousFunctionalCalculus ℝ (IsSelfAdjoint : A → Prop)]
    {a : A} (ha₁ : IsSelfAdjoint a) (ha₂ : QuasispectrumRestricts a ContinuousMap.realToNNReal) :
    ∃ x : A, IsSelfAdjoint x ∧ QuasispectrumRestricts x ContinuousMap.realToNNReal ∧ x * x = a 
goal: ∃ x, IsSelfAdjoint x ∧ QuasispectrumRestricts x ⇑ContinuousMap.realToNNReal ∧ x * x = a

full_name: nonneg_iff_isSelfAdjoint_and_quasispectrumRestricts
code: lemma nonneg_iff_isSelfAdjoint_and_quasispectrumRestricts {a : A} :
    0 ≤ a ↔ IsSelfAdjoint a ∧ QuasispectrumRestricts a ContinuousMap.realToNNReal 
goal: 0 ≤ a ↔ IsSelfAdjoint a ∧ QuasispectrumRestricts a ⇑ContinuousMap.realToNNReal

full_name: Nonneg.instNonUnitalContinuousFunctionalCalculus
code: instance Nonneg.instNonUnitalContinuousFunctionalCalculus [∀ a : A, CompactSpace (σₙ ℝ a)] :
    NonUnitalContinuousFunctionalCalculus ℝ≥0 (fun x : A ↦ 0 ≤ x) 
goal: NonUnitalContinuousFunctionalCalculus NNReal fun x => 0 ≤ x

full_name: CFC.exists_sqrt_of_isSelfAdjoint_of_spectrumRestricts
code: lemma CFC.exists_sqrt_of_isSelfAdjoint_of_spectrumRestricts {A : Type*} [Ring A] [StarRing A]
    [TopologicalSpace A] [Algebra ℝ A] [ContinuousFunctionalCalculus ℝ (IsSelfAdjoint : A → Prop)]
    {a : A} (ha₁ : IsSelfAdjoint a) (ha₂ : SpectrumRestricts a ContinuousMap.realToNNReal) :
    ∃ x : A, IsSelfAdjoint x ∧ SpectrumRestricts x ContinuousMap.realToNNReal ∧ x ^ 2 = a 
goal: ∃ x, IsSelfAdjoint x ∧ SpectrumRestricts x ⇑ContinuousMap.realToNNReal ∧ x ^ 2 = a

full_name: nonneg_iff_isSelfAdjoint_and_spectrumRestricts
code: lemma nonneg_iff_isSelfAdjoint_and_spectrumRestricts {a : A} :
    0 ≤ a ↔ IsSelfAdjoint a ∧ SpectrumRestricts a ContinuousMap.realToNNReal 
goal: 0 ≤ a ↔ IsSelfAdjoint a ∧ SpectrumRestricts a ⇑ContinuousMap.realToNNReal

full_name: Nonneg.instContinuousFunctionalCalculus
code: instance Nonneg.instContinuousFunctionalCalculus [∀ a : A, CompactSpace (spectrum ℝ a)] :
    ContinuousFunctionalCalculus ℝ≥0 (fun x : A ↦ 0 ≤ x) 
goal: ContinuousFunctionalCalculus NNReal fun x => 0 ≤ x

full_name: SpectrumRestricts.nnreal_iff_nnnorm
code: lemma SpectrumRestricts.nnreal_iff_nnnorm {a : A} {t : ℝ≥0} (ha : IsSelfAdjoint a) (ht : ‖a‖₊ ≤ t) :
    SpectrumRestricts a ContinuousMap.realToNNReal ↔ ‖algebraMap ℝ A t - a‖₊ ≤ t 
goal: SpectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ ‖(algebraMap ℝ A) ↑t - a‖₊ ≤ t

full_name: SpectrumRestricts.nnreal_add
code: lemma SpectrumRestricts.nnreal_add {a b : A} (ha₁ : IsSelfAdjoint a)
    (hb₁ : IsSelfAdjoint b) (ha₂ : SpectrumRestricts a ContinuousMap.realToNNReal)
    (hb₂ : SpectrumRestricts b ContinuousMap.realToNNReal) :
    SpectrumRestricts (a + b) ContinuousMap.realToNNReal 
goal: SpectrumRestricts (a + b) ⇑ContinuousMap.realToNNReal

full_name: IsSelfAdjoint.sq_spectrumRestricts
code: lemma IsSelfAdjoint.sq_spectrumRestricts {a : A} (ha : IsSelfAdjoint a) :
    SpectrumRestricts (a ^ 2) ContinuousMap.realToNNReal 
goal: SpectrumRestricts (a ^ 2) ⇑ContinuousMap.realToNNReal

full_name: SpectrumRestricts.eq_zero_of_neg
code: lemma SpectrumRestricts.eq_zero_of_neg {a : A} (ha : IsSelfAdjoint a)
    (ha₁ : SpectrumRestricts a ContinuousMap.realToNNReal)
    (ha₂ : SpectrumRestricts (-a) ContinuousMap.realToNNReal) :
    a = 0 
goal: a = 0

full_name: SpectrumRestricts.smul_of_nonneg
code: lemma SpectrumRestricts.smul_of_nonneg {A : Type*} [Ring A] [Algebra ℝ A] {a : A}
    (ha : SpectrumRestricts a ContinuousMap.realToNNReal) {r : ℝ} (hr : 0 ≤ r) :
    SpectrumRestricts (r • a) ContinuousMap.realToNNReal 
goal: SpectrumRestricts (r • a) ⇑ContinuousMap.realToNNReal

full_name: spectrum_star_mul_self_nonneg
code: lemma spectrum_star_mul_self_nonneg {b : A} : ∀ x ∈ spectrum ℝ (star b * b), 0 ≤ x 
goal: x ∈ spectrum ℝ (star b * b) → 0 ≤ x

full_name: IsSelfAdjoint.coe_mem_spectrum_complex
code: lemma IsSelfAdjoint.coe_mem_spectrum_complex {A : Type*} [TopologicalSpace A] [Ring A]
    [StarRing A] [Algebra ℂ A] [ContinuousFunctionalCalculus ℂ (IsStarNormal : A → Prop)]
    {a : A} {x : ℝ} (ha : IsSelfAdjoint a := by cfc_tac) :
    (x : ℂ) ∈ spectrum ℂ a ↔ x ∈ spectrum ℝ a 
goal: ↑x ∈ spectrum ℂ a ↔ x ∈ spectrum ℝ a

full_name: CstarRing.instNonnegSpectrumClass
code: instance CstarRing.instNonnegSpectrumClass : NonnegSpectrumClass ℝ A 
goal: NonnegSpectrumClass ℝ A

full_name: CstarRing.instNonnegSpectrumClassComplexUnital
code: instance CstarRing.instNonnegSpectrumClassComplexUnital : NonnegSpectrumClass ℂ A 
goal: NonnegSpectrumClass ℂ A

full_name: CstarRing.spectralOrder
code: /-- The partial order on a unital C⋆-algebra defined by `x ≤ y` if and only if `y - x` is
selfadjoint and has nonnegative spectrum.

This is not declared as an instance because one may already have a partial order with better
definitional properties. However, it can be useful to invoke this as an instance in proofs. -/
@[reducible]
def CstarRing.spectralOrder : PartialOrder A 
goal: PartialOrder A

full_name: CstarRing.spectralOrderedRing
code: /-- The `CstarRing.spectralOrder` on a unital C⋆-algebra is a `StarOrderedRing`. -/
lemma CstarRing.spectralOrderedRing : @StarOrderedRing A _ (CstarRing.spectralOrder A) _ 
goal: StarOrderedRing A

full_name: CstarRing.instNonnegSpectrumClass'
code: instance CstarRing.instNonnegSpectrumClass' : NonnegSpectrumClass ℝ A 
goal: NonnegSpectrumClass ℝ A

full_name: cfcHom_real_eq_restrict
code: lemma cfcHom_real_eq_restrict {a : A} (ha : IsSelfAdjoint a) :
    cfcHom ha = ha.spectrumRestricts.starAlgHom (cfcHom ha.isStarNormal) (f := Complex.reCLM) 
goal: cfcHom ha = SpectrumRestricts.starAlgHom (cfcHom ⋯) ⋯

full_name: cfc_real_eq_complex
code: lemma cfc_real_eq_complex {a : A} (f : ℝ → ℝ) (ha : IsSelfAdjoint a := by cfc_tac)  :
    cfc f a = cfc (fun x ↦ f x.re : ℂ → ℂ) a 
goal: cfc f a = cfc (fun x => ↑(f x.re)) a

full_name: cfcHom_nnreal_eq_restrict
code: lemma cfcHom_nnreal_eq_restrict {a : A} (ha : 0 ≤ a) :
    cfcHom ha = (SpectrumRestricts.nnreal_of_nonneg ha).starAlgHom
      (cfcHom (IsSelfAdjoint.of_nonneg ha)) 
goal: cfcHom ha = SpectrumRestricts.starAlgHom (cfcHom ⋯) ⋯

full_name: cfc_nnreal_eq_real
code: lemma cfc_nnreal_eq_real {a : A} (f : ℝ≥0 → ℝ≥0) (ha : 0 ≤ a := by cfc_tac)  :
    cfc f a = cfc (fun x ↦ f x.toNNReal : ℝ → ℝ) a 
goal: cfc f a = cfc (fun x => ↑(f x.toNNReal)) a