File: Mathlib/Analysis/Normed/Algebra/Spectrum.lean

full_name: spectralRadius
code: /-- The *spectral radius* is the supremum of the `nnnorm` (`‖·‖₊`) of elements in the spectrum,
    coerced into an element of `ℝ≥0∞`. Note that it is possible for `spectrum 𝕜 a = ∅`. In this
    case, `spectralRadius a = 0`. It is also possible that `spectrum 𝕜 a` be unbounded (though
    not for Banach algebras, see `spectrum.isBounded`, below).  In this case,
    `spectralRadius a = ∞`. -/
noncomputable def spectralRadius (𝕜 : Type*) {A : Type*} [NormedField 𝕜] [Ring A] [Algebra 𝕜 A]
    (a : A) : ℝ≥0∞ 
goal: ℝ≥0∞

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

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

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_spectrum_termρ_1
code: local notation "ρ" => resolventSet 𝕜
goal: Lean.Macro

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_resolventSet_1
code: local notation "ρ" => resolventSet 𝕜
goal: Lean.PrettyPrinter.Unexpander

full_name: spectrum.«_aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_spectrum_term↑ₐ_1»
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.Macro

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_algebraMap_1
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.PrettyPrinter.Unexpander

full_name: spectrum.SpectralRadius.of_subsingleton
code: @[simp]
theorem SpectralRadius.of_subsingleton [Subsingleton A] (a : A) : spectralRadius 𝕜 a = 0 
goal: spectralRadius 𝕜 a = 0

full_name: spectrum.spectralRadius_zero
code: @[simp]
theorem spectralRadius_zero : spectralRadius 𝕜 (0 : A) = 0 
goal: spectralRadius 𝕜 0 = 0

full_name: spectrum.mem_resolventSet_of_spectralRadius_lt
code: theorem mem_resolventSet_of_spectralRadius_lt {a : A} {k : 𝕜} (h : spectralRadius 𝕜 a < ‖k‖₊) :
    k ∈ ρ a 
goal: k ∈ resolventSet 𝕜 a

full_name: spectrum.isOpen_resolventSet
code: theorem isOpen_resolventSet (a : A) : IsOpen (ρ a) 
goal: IsOpen (resolventSet 𝕜 a)

full_name: spectrum.isClosed
code: protected theorem isClosed (a : A) : IsClosed (σ a) 
goal: IsClosed (spectrum 𝕜 a)

full_name: spectrum.mem_resolventSet_of_norm_lt_mul
code: theorem mem_resolventSet_of_norm_lt_mul {a : A} {k : 𝕜} (h : ‖a‖ * ‖(1 : A)‖ < ‖k‖) : k ∈ ρ a 
goal: k ∈ resolventSet 𝕜 a

full_name: spectrum.mem_resolventSet_of_norm_lt
code: theorem mem_resolventSet_of_norm_lt [NormOneClass A] {a : A} {k : 𝕜} (h : ‖a‖ < ‖k‖) : k ∈ ρ a 
goal: k ∈ resolventSet 𝕜 a

full_name: spectrum.norm_le_norm_mul_of_mem
code: theorem norm_le_norm_mul_of_mem {a : A} {k : 𝕜} (hk : k ∈ σ a) : ‖k‖ ≤ ‖a‖ * ‖(1 : A)‖ 
goal: ‖k‖ ≤ ‖a‖ * ‖1‖

full_name: spectrum.norm_le_norm_of_mem
code: theorem norm_le_norm_of_mem [NormOneClass A] {a : A} {k : 𝕜} (hk : k ∈ σ a) : ‖k‖ ≤ ‖a‖ 
goal: ‖k‖ ≤ ‖a‖

full_name: spectrum.subset_closedBall_norm_mul
code: theorem subset_closedBall_norm_mul (a : A) : σ a ⊆ Metric.closedBall (0 : 𝕜) (‖a‖ * ‖(1 : A)‖) 
goal: spectrum 𝕜 a ⊆ Metric.closedBall 0 (‖a‖ * ‖1‖)

full_name: spectrum.subset_closedBall_norm
code: theorem subset_closedBall_norm [NormOneClass A] (a : A) : σ a ⊆ Metric.closedBall (0 : 𝕜) ‖a‖ 
goal: spectrum 𝕜 a ⊆ Metric.closedBall 0 ‖a‖

full_name: spectrum.isBounded
code: theorem isBounded (a : A) : Bornology.IsBounded (σ a) 
goal: Bornology.IsBounded (spectrum 𝕜 a)

full_name: spectrum.isCompact
code: protected theorem isCompact [ProperSpace 𝕜] (a : A) : IsCompact (σ a) 
goal: IsCompact (spectrum 𝕜 a)

full_name: spectrum.instCompactSpace
code: instance instCompactSpace [ProperSpace 𝕜] (a : A) : CompactSpace (spectrum 𝕜 a) 
goal: CompactSpace ↑(spectrum 𝕜 a)

full_name: spectrum.instCompactSpaceNNReal
code: instance instCompactSpaceNNReal {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    (a : A) [CompactSpace (spectrum ℝ a)] : CompactSpace (spectrum ℝ≥0 a) 
goal: CompactSpace ↑(spectrum ℝ≥0 a)

full_name: quasispectrum.isCompact
code: theorem _root_.quasispectrum.isCompact (a : B) : IsCompact (quasispectrum 𝕜 a) 
goal: IsCompact (quasispectrum 𝕜 a)

full_name: quasispectrum.instCompactSpace
code: instance _root_.quasispectrum.instCompactSpace (a : B) :
    CompactSpace (quasispectrum 𝕜 a) 
goal: CompactSpace ↑(quasispectrum 𝕜 a)

full_name: quasispectrum.instCompactSpaceNNReal
code: instance _root_.quasispectrum.instCompactSpaceNNReal [NormedSpace ℝ B] [IsScalarTower ℝ B B]
    [SMulCommClass ℝ B B] (a : B) [CompactSpace (quasispectrum ℝ a)] :
    CompactSpace (quasispectrum ℝ≥0 a) 
goal: CompactSpace ↑(quasispectrum ℝ≥0 a)

full_name: spectrum.spectralRadius_le_nnnorm
code: theorem spectralRadius_le_nnnorm [NormOneClass A] (a : A) : spectralRadius 𝕜 a ≤ ‖a‖₊ 
goal: spectralRadius 𝕜 a ≤ ↑‖a‖₊

full_name: spectrum.exists_nnnorm_eq_spectralRadius_of_nonempty
code: theorem exists_nnnorm_eq_spectralRadius_of_nonempty [ProperSpace 𝕜] {a : A} (ha : (σ a).Nonempty) :
    ∃ k ∈ σ a, (‖k‖₊ : ℝ≥0∞) = spectralRadius 𝕜 a 
goal: ∃ k ∈ spectrum 𝕜 a, ↑‖k‖₊ = spectralRadius 𝕜 a

full_name: spectrum.spectralRadius_lt_of_forall_lt_of_nonempty
code: theorem spectralRadius_lt_of_forall_lt_of_nonempty [ProperSpace 𝕜] {a : A} (ha : (σ a).Nonempty)
    {r : ℝ≥0} (hr : ∀ k ∈ σ a, ‖k‖₊ < r) : spectralRadius 𝕜 a < r 
goal: spectralRadius 𝕜 a < ↑r

full_name: spectrum.spectralRadius_le_pow_nnnorm_pow_one_div
code: theorem spectralRadius_le_pow_nnnorm_pow_one_div (a : A) (n : ℕ) :
    spectralRadius 𝕜 a ≤ (‖a ^ (n + 1)‖₊ : ℝ≥0∞) ^ (1 / (n + 1) : ℝ) *
      (‖(1 : A)‖₊ : ℝ≥0∞) ^ (1 / (n + 1) : ℝ) 
goal: spectralRadius 𝕜 a ≤ ↑‖a ^ (n + 1)‖₊ ^ (1 / (↑n + 1)) * ↑‖1‖₊ ^ (1 / (↑n + 1))

full_name: spectrum.spectralRadius_le_liminf_pow_nnnorm_pow_one_div
code: theorem spectralRadius_le_liminf_pow_nnnorm_pow_one_div (a : A) :
    spectralRadius 𝕜 a ≤ atTop.liminf fun n : ℕ => (‖a ^ n‖₊ : ℝ≥0∞) ^ (1 / n : ℝ) 
goal: spectralRadius 𝕜 a ≤ Filter.liminf (fun n => ↑‖a ^ n‖₊ ^ (1 / ↑n)) Filter.atTop

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_spectrum_termρ_2
code: local notation "ρ" => resolventSet 𝕜
goal: Lean.Macro

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_resolventSet_2
code: local notation "ρ" => resolventSet 𝕜
goal: Lean.PrettyPrinter.Unexpander

full_name: spectrum.«_aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_spectrum_term↑ₐ_2»
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.Macro

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_algebraMap_2
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.PrettyPrinter.Unexpander

full_name: spectrum.hasDerivAt_resolvent
code: theorem hasDerivAt_resolvent {a : A} {k : 𝕜} (hk : k ∈ ρ a) :
    HasDerivAt (resolvent a) (-resolvent a k ^ 2) k 
goal: HasDerivAt (resolvent a) (-resolvent a k ^ 2) k

full_name: spectrum.eventually_isUnit_resolvent
code: theorem eventually_isUnit_resolvent (a : A) : ∀ᶠ z in cobounded 𝕜, IsUnit (resolvent a z) 
goal: ∀ᶠ (z : 𝕜) in Bornology.cobounded 𝕜, IsUnit (resolvent a z)

full_name: spectrum.resolvent_isBigO_inv
code: theorem resolvent_isBigO_inv (a : A) : resolvent a =O[cobounded 𝕜] Inv.inv 
goal: resolvent a =O[Bornology.cobounded 𝕜] Inv.inv

full_name: spectrum.resolvent_tendsto_cobounded
code: theorem resolvent_tendsto_cobounded (a : A) : Tendsto (resolvent a) (cobounded 𝕜) (𝓝 0) 
goal: Filter.Tendsto (resolvent a) (Bornology.cobounded 𝕜) (nhds 0)

full_name: spectrum.hasFPowerSeriesOnBall_inverse_one_sub_smul
code: /-- In a Banach algebra `A` over a nontrivially normed field `𝕜`, for any `a : A` the
power series with coefficients `a ^ n` represents the function `(1 - z • a)⁻¹` in a disk of
radius `‖a‖₊⁻¹`. -/
theorem hasFPowerSeriesOnBall_inverse_one_sub_smul [CompleteSpace A] (a : A) :
    HasFPowerSeriesOnBall (fun z : 𝕜 => Ring.inverse (1 - z • a))
      (fun n => ContinuousMultilinearMap.mkPiRing 𝕜 (Fin n) (a ^ n)) 0 ‖a‖₊⁻¹ 
goal: HasFPowerSeriesOnBall (fun z => Ring.inverse (1 - z • a)) (fun n => ContinuousMultilinearMap.mkPiRing 𝕜 (Fin n) (a ^ n))
  0 (↑‖a‖₊)⁻¹

full_name: spectrum.isUnit_one_sub_smul_of_lt_inv_radius
code: theorem isUnit_one_sub_smul_of_lt_inv_radius {a : A} {z : 𝕜} (h : ↑‖z‖₊ < (spectralRadius 𝕜 a)⁻¹) :
    IsUnit (1 - z • a) 
goal: IsUnit (1 - z • a)

full_name: spectrum.differentiableOn_inverse_one_sub_smul
code: /-- In a Banach algebra `A` over `𝕜`, for `a : A` the function `fun z ↦ (1 - z • a)⁻¹` is
differentiable on any closed ball centered at zero of radius `r < (spectralRadius 𝕜 a)⁻¹`. -/
theorem differentiableOn_inverse_one_sub_smul [CompleteSpace A] {a : A} {r : ℝ≥0}
    (hr : (r : ℝ≥0∞) < (spectralRadius 𝕜 a)⁻¹) :
    DifferentiableOn 𝕜 (fun z : 𝕜 => Ring.inverse (1 - z • a)) (Metric.closedBall 0 r) 
goal: DifferentiableOn 𝕜 (fun z => Ring.inverse (1 - z • a)) (Metric.closedBall 0 ↑r)

full_name: spectrum.limsup_pow_nnnorm_pow_one_div_le_spectralRadius
code: /-- The `limsup` relationship for the spectral radius used to prove `spectrum.gelfand_formula`. -/
theorem limsup_pow_nnnorm_pow_one_div_le_spectralRadius (a : A) :
    limsup (fun n : ℕ => (‖a ^ n‖₊ : ℝ≥0∞) ^ (1 / n : ℝ)) atTop ≤ spectralRadius ℂ a 
goal: Filter.limsup (fun n => ↑‖a ^ n‖₊ ^ (1 / ↑n)) Filter.atTop ≤ spectralRadius ℂ a

full_name: spectrum.pow_nnnorm_pow_one_div_tendsto_nhds_spectralRadius
code: /-- **Gelfand's formula**: Given an element `a : A` of a complex Banach algebra, the
`spectralRadius` of `a` is the limit of the sequence `‖a ^ n‖₊ ^ (1 / n)`. -/
theorem pow_nnnorm_pow_one_div_tendsto_nhds_spectralRadius (a : A) :
    Tendsto (fun n : ℕ => (‖a ^ n‖₊ : ℝ≥0∞) ^ (1 / n : ℝ)) atTop (𝓝 (spectralRadius ℂ a)) 
goal: Filter.Tendsto (fun n => ↑‖a ^ n‖₊ ^ (1 / ↑n)) Filter.atTop (nhds (spectralRadius ℂ a))

full_name: spectrum.pow_norm_pow_one_div_tendsto_nhds_spectralRadius
code: /-- **Gelfand's formula**: Given an element `a : A` of a complex Banach algebra, the
`spectralRadius` of `a` is the limit of the sequence `‖a ^ n‖₊ ^ (1 / n)`. -/
theorem pow_norm_pow_one_div_tendsto_nhds_spectralRadius (a : A) :
    Tendsto (fun n : ℕ => ENNReal.ofReal (‖a ^ n‖ ^ (1 / n : ℝ))) atTop
      (𝓝 (spectralRadius ℂ a)) 
goal: Filter.Tendsto (fun n => ENNReal.ofReal (‖a ^ n‖ ^ (1 / ↑n))) Filter.atTop (nhds (spectralRadius ℂ a))

full_name: spectrum.nonempty
code: /-- In a (nontrivial) complex Banach algebra, every element has nonempty spectrum. -/
protected theorem nonempty : (spectrum ℂ a).Nonempty 
goal: (spectrum ℂ a).Nonempty

full_name: spectrum.exists_nnnorm_eq_spectralRadius
code: /-- In a complex Banach algebra, the spectral radius is always attained by some element of the
spectrum. -/
theorem exists_nnnorm_eq_spectralRadius : ∃ z ∈ spectrum ℂ a, (‖z‖₊ : ℝ≥0∞) = spectralRadius ℂ a 
goal: ∃ z ∈ spectrum ℂ a, ↑‖z‖₊ = spectralRadius ℂ a

full_name: spectrum.spectralRadius_lt_of_forall_lt
code: /-- In a complex Banach algebra, if every element of the spectrum has norm strictly less than
`r : ℝ≥0`, then the spectral radius is also strictly less than `r`. -/
theorem spectralRadius_lt_of_forall_lt {r : ℝ≥0} (hr : ∀ z ∈ spectrum ℂ a, ‖z‖₊ < r) :
    spectralRadius ℂ a < r 
goal: spectralRadius ℂ a < ↑r

full_name: spectrum.map_polynomial_aeval
code: /-- The **spectral mapping theorem** for polynomials in a Banach algebra over `ℂ`. -/
theorem map_polynomial_aeval (p : ℂ[X]) :
    spectrum ℂ (aeval a p) = (fun k => eval k p) '' spectrum ℂ a 
goal: spectrum ℂ ((Polynomial.aeval a) p) = (fun k => Polynomial.eval k p) '' spectrum ℂ a

full_name: spectrum.map_pow
code: /-- A specialization of the spectral mapping theorem for polynomials in a Banach algebra over `ℂ`
to monic monomials. -/
protected theorem map_pow (n : ℕ) :
    spectrum ℂ (a ^ n) = (· ^ n) '' spectrum ℂ a 
goal: spectrum ℂ (a ^ n) = (fun x => x ^ n) '' spectrum ℂ a

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_spectrum_termσ_2
code: local notation "σ" => spectrum ℂ
goal: Lean.Macro

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

full_name: spectrum.algebraMap_eq_of_mem
code: theorem algebraMap_eq_of_mem {a : A} {z : ℂ} (h : z ∈ σ a) : algebraMap ℂ A z = a 
goal: (algebraMap ℂ A) z = a

full_name: NormedRing.algEquivComplexOfComplete_apply
code: /-- **Gelfand-Mazur theorem**: For a complex Banach division algebra, the natural `algebraMap ℂ A`
is an algebra isomorphism whose inverse is given by selecting the (unique) element of
`spectrum ℂ a`. In addition, `algebraMap_isometry` guarantees this map is an isometry.

Note: because `NormedDivisionRing` requires the field `norm_mul' : ∀ a b, ‖a * b‖ = ‖a‖ * ‖b‖`, we
don't use this type class and instead opt for a `NormedRing` in which the nonzero elements are
precisely the units. This allows for the application of this isomorphism in broader contexts, e.g.,
to the quotient of a complex Banach algebra by a maximal ideal. In the case when `A` is actually a
`NormedDivisionRing`, one may fill in the argument `hA` with the lemma `isUnit_iff_ne_zero`. -/
@[simps]
noncomputable def _root_.NormedRing.algEquivComplexOfComplete [CompleteSpace A] : ℂ ≃ₐ[ℂ] A 
goal: (NormedRing.algEquivComplexOfComplete hA) a = (algebraMap ℂ A) a

full_name: NormedRing.algEquivComplexOfComplete_symm_apply
code: /-- **Gelfand-Mazur theorem**: For a complex Banach division algebra, the natural `algebraMap ℂ A`
is an algebra isomorphism whose inverse is given by selecting the (unique) element of
`spectrum ℂ a`. In addition, `algebraMap_isometry` guarantees this map is an isometry.

Note: because `NormedDivisionRing` requires the field `norm_mul' : ∀ a b, ‖a * b‖ = ‖a‖ * ‖b‖`, we
don't use this type class and instead opt for a `NormedRing` in which the nonzero elements are
precisely the units. This allows for the application of this isomorphism in broader contexts, e.g.,
to the quotient of a complex Banach algebra by a maximal ideal. In the case when `A` is actually a
`NormedDivisionRing`, one may fill in the argument `hA` with the lemma `isUnit_iff_ne_zero`. -/
@[simps]
noncomputable def _root_.NormedRing.algEquivComplexOfComplete [CompleteSpace A] : ℂ ≃ₐ[ℂ] A 
goal: (NormedRing.algEquivComplexOfComplete hA).symm a = ⋯.some

full_name: NormedRing.algEquivComplexOfComplete
code: /-- **Gelfand-Mazur theorem**: For a complex Banach division algebra, the natural `algebraMap ℂ A`
is an algebra isomorphism whose inverse is given by selecting the (unique) element of
`spectrum ℂ a`. In addition, `algebraMap_isometry` guarantees this map is an isometry.

Note: because `NormedDivisionRing` requires the field `norm_mul' : ∀ a b, ‖a * b‖ = ‖a‖ * ‖b‖`, we
don't use this type class and instead opt for a `NormedRing` in which the nonzero elements are
precisely the units. This allows for the application of this isomorphism in broader contexts, e.g.,
to the quotient of a complex Banach algebra by a maximal ideal. In the case when `A` is actually a
`NormedDivisionRing`, one may fill in the argument `hA` with the lemma `isUnit_iff_ne_zero`. -/
@[simps]
noncomputable def _root_.NormedRing.algEquivComplexOfComplete [CompleteSpace A] : ℂ ≃ₐ[ℂ] A 
goal: ℂ ≃ₐ[ℂ] A

full_name: spectrum.«_aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_spectrum_term↑ₐ_3»
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.Macro

full_name: spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_algebraMap_3
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.PrettyPrinter.Unexpander

full_name: spectrum.exp_mem_exp
code: /-- For `𝕜 = ℝ` or `𝕜 = ℂ`, `exp 𝕜` maps the spectrum of `a` into the spectrum of `exp 𝕜 a`. -/
theorem exp_mem_exp [RCLike 𝕜] [NormedRing A] [NormedAlgebra 𝕜 A] [CompleteSpace A] (a : A)
    {z : 𝕜} (hz : z ∈ spectrum 𝕜 a) : exp 𝕜 z ∈ spectrum 𝕜 (exp 𝕜 a) 
goal: NormedSpace.exp 𝕜 z ∈ spectrum 𝕜 (NormedSpace.exp 𝕜 a)

full_name: AlgHom.«_aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_AlgHom_term↑ₐ_1»
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.Macro

full_name: AlgHom._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_algebraMap_1
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.PrettyPrinter.Unexpander

full_name: AlgHom.instContinuousLinearMapClassOfAlgHomClass
code: instance (priority := 100) [FunLike F A 𝕜] [AlgHomClass F 𝕜 A 𝕜] :
    ContinuousLinearMapClass F 𝕜 A 𝕜 
goal: ContinuousLinearMapClass F 𝕜 A 𝕜

full_name: AlgHom.toContinuousLinearMap
code: /-- An algebra homomorphism into the base field, as a continuous linear map (since it is
automatically bounded). -/
def toContinuousLinearMap (φ : A →ₐ[𝕜] 𝕜) : A →L[𝕜] 𝕜 
goal: A →L[𝕜] 𝕜

full_name: AlgHom.coe_toContinuousLinearMap
code: @[simp]
theorem coe_toContinuousLinearMap (φ : A →ₐ[𝕜] 𝕜) : ⇑φ.toContinuousLinearMap = φ 
goal: ⇑φ.toContinuousLinearMap = ⇑φ

full_name: AlgHom.norm_apply_le_self_mul_norm_one
code: theorem norm_apply_le_self_mul_norm_one [FunLike F A 𝕜] [AlgHomClass F 𝕜 A 𝕜] (f : F) (a : A) :
    ‖f a‖ ≤ ‖a‖ * ‖(1 : A)‖ 
goal: ‖f a‖ ≤ ‖a‖ * ‖1‖

full_name: AlgHom.norm_apply_le_self
code: theorem norm_apply_le_self [NormOneClass A] [FunLike F A 𝕜] [AlgHomClass F 𝕜 A 𝕜]
    (f : F) (a : A) : ‖f a‖ ≤ ‖a‖ 
goal: ‖f a‖ ≤ ‖a‖

full_name: AlgHom.«_aux_Mathlib_Analysis_Normed_Algebra_Spectrum___macroRules_AlgHom_term↑ₐ_2»
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.Macro

full_name: AlgHom._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_algebraMap_2
code: local notation "↑ₐ" => algebraMap 𝕜 A
goal: Lean.PrettyPrinter.Unexpander

full_name: AlgHom.toContinuousLinearMap_norm
code: @[simp]
theorem toContinuousLinearMap_norm [NormOneClass A] (φ : A →ₐ[𝕜] 𝕜) :
    ‖φ.toContinuousLinearMap‖ = 1 
goal: ‖φ.toContinuousLinearMap‖ = 1

full_name: WeakDual.CharacterSpace.equivAlgHom
code: /-- The equivalence between characters and algebra homomorphisms into the base field. -/
def equivAlgHom : characterSpace 𝕜 A ≃ (A →ₐ[𝕜] 𝕜) 
goal: ↑(WeakDual.characterSpace 𝕜 A) ≃ (A →ₐ[𝕜] 𝕜)

full_name: WeakDual.CharacterSpace.equivAlgHom_coe
code: @[simp]
theorem equivAlgHom_coe (f : characterSpace 𝕜 A) : ⇑(equivAlgHom f) = f 
goal: ⇑(WeakDual.CharacterSpace.equivAlgHom f) = ⇑f

full_name: WeakDual.CharacterSpace.equivAlgHom_symm_coe
code: @[simp]
theorem equivAlgHom_symm_coe (f : A →ₐ[𝕜] 𝕜) : ⇑(equivAlgHom.symm f) = f 
goal: ⇑(WeakDual.CharacterSpace.equivAlgHom.symm f) = ⇑f

full_name: SpectrumRestricts.spectralRadius_eq
code: /-- If `𝕜₁` is a normed field contained as subfield of a larger normed field `𝕜₂`, and if `a : A`
is an element whose `𝕜₂` spectrum restricts to `𝕜₁`, then the spectral radii over each scalar
field coincide. -/
lemma spectralRadius_eq {𝕜₁ 𝕜₂ A : Type*} [NormedField 𝕜₁] [NormedField 𝕜₂]
    [NormedRing A] [NormedAlgebra 𝕜₁ A] [NormedAlgebra 𝕜₂ A] [NormedAlgebra 𝕜₁ 𝕜₂]
    [IsScalarTower 𝕜₁ 𝕜₂ A] {f : 𝕜₂ → 𝕜₁} {a : A} (h : SpectrumRestricts a f) :
    spectralRadius 𝕜₁ a = spectralRadius 𝕜₂ a 
goal: spectralRadius 𝕜₁ a = spectralRadius 𝕜₂ a

full_name: SpectrumRestricts.nnreal_iff
code: lemma nnreal_iff [Algebra ℝ A] {a : A} :
    SpectrumRestricts a ContinuousMap.realToNNReal ↔ ∀ x ∈ spectrum ℝ a, 0 ≤ x 
goal: SpectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ ∀ x ∈ spectrum ℝ a, 0 ≤ x

full_name: SpectrumRestricts.nnreal_of_nonneg
code: lemma nnreal_of_nonneg {A : Type*} [Ring A] [PartialOrder A] [Algebra ℝ A]
    [NonnegSpectrumClass ℝ A] {a : A} (ha : 0 ≤ a) :
    SpectrumRestricts a ContinuousMap.realToNNReal 
goal: SpectrumRestricts a ⇑ContinuousMap.realToNNReal

full_name: SpectrumRestricts.real_iff
code: lemma real_iff [Algebra ℂ A] {a : A} :
    SpectrumRestricts a Complex.reCLM ↔ ∀ x ∈ spectrum ℂ a, x = x.re 
goal: SpectrumRestricts a ⇑Complex.reCLM ↔ ∀ x ∈ spectrum ℂ a, x = ↑x.re

full_name: SpectrumRestricts.nnreal_iff_spectralRadius_le
code: lemma nnreal_iff_spectralRadius_le [Algebra ℝ A] {a : A} {t : ℝ≥0} (ht : spectralRadius ℝ a ≤ t) :
    SpectrumRestricts a ContinuousMap.realToNNReal ↔
      spectralRadius ℝ (algebraMap ℝ A t - a) ≤ t 
goal: SpectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ spectralRadius ℝ ((algebraMap ℝ A) ↑t - a) ≤ ↑t

full_name: NNReal.spectralRadius_mem_spectrum
code: lemma _root_.NNReal.spectralRadius_mem_spectrum {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] {a : A} (ha : (spectrum ℝ a).Nonempty)
    (ha' : SpectrumRestricts a ContinuousMap.realToNNReal) :
    (spectralRadius ℝ a).toNNReal ∈ spectrum ℝ≥0 a 
goal: (spectralRadius ℝ a).toNNReal ∈ spectrum ℝ≥0 a

full_name: Real.spectralRadius_mem_spectrum
code: lemma _root_.Real.spectralRadius_mem_spectrum {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] {a : A} (ha : (spectrum ℝ a).Nonempty)
    (ha' : SpectrumRestricts a ContinuousMap.realToNNReal) :
    (spectralRadius ℝ a).toReal ∈ spectrum ℝ a 
goal: (spectralRadius ℝ a).toReal ∈ spectrum ℝ a

full_name: Real.spectralRadius_mem_spectrum_or
code: lemma _root_.Real.spectralRadius_mem_spectrum_or {A : Type*} [NormedRing A] [NormedAlgebra ℝ A]
    [CompleteSpace A] {a : A} (ha : (spectrum ℝ a).Nonempty) :
    (spectralRadius ℝ a).toReal ∈ spectrum ℝ a ∨ -(spectralRadius ℝ a).toReal ∈ spectrum ℝ a 
goal: (spectralRadius ℝ a).toReal ∈ spectrum ℝ a ∨ -(spectralRadius ℝ a).toReal ∈ spectrum ℝ a

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

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

full_name: QuasispectrumRestricts.compactSpace
code: lemma compactSpace {R S A : Type*} [Semifield R] [Field S] [NonUnitalRing A]
    [Algebra R S] [Module R A] [Module S A] [IsScalarTower S A A] [SMulCommClass S A A]
    [IsScalarTower R S A] [TopologicalSpace R] [TopologicalSpace S] {a : A} (f : C(S, R))
    (h : QuasispectrumRestricts a f) [h_cpct : CompactSpace (σₙ S a)] :
    CompactSpace (σₙ R a) 
goal: CompactSpace ↑(quasispectrum R a)

full_name: QuasispectrumRestricts.nnreal_iff
code: lemma nnreal_iff [Module ℝ A] [IsScalarTower ℝ A A] [SMulCommClass ℝ A A] {a : A} :
    QuasispectrumRestricts a ContinuousMap.realToNNReal ↔ ∀ x ∈ σₙ ℝ a, 0 ≤ x 
goal: QuasispectrumRestricts a ⇑ContinuousMap.realToNNReal ↔ ∀ x ∈ quasispectrum ℝ a, 0 ≤ x

full_name: QuasispectrumRestricts.nnreal_of_nonneg
code: lemma nnreal_of_nonneg [Module ℝ A] [IsScalarTower ℝ A A] [SMulCommClass ℝ A A] [PartialOrder A]
    [NonnegSpectrumClass ℝ A] {a : A} (ha : 0 ≤ a) :
    QuasispectrumRestricts a ContinuousMap.realToNNReal 
goal: QuasispectrumRestricts a ⇑ContinuousMap.realToNNReal

full_name: QuasispectrumRestricts.real_iff
code: lemma real_iff [Module ℂ A] [IsScalarTower ℂ A A] [SMulCommClass ℂ A A] {a : A} :
    QuasispectrumRestricts a Complex.reCLM ↔ ∀ x ∈ σₙ ℂ a, x = x.re 
goal: QuasispectrumRestricts a ⇑Complex.reCLM ↔ ∀ x ∈ quasispectrum ℂ a, x = ↑x.re

full_name: coe_mem_spectrum_real_of_nonneg
code: lemma coe_mem_spectrum_real_of_nonneg [Algebra ℝ A] [NonnegSpectrumClass ℝ A] {a : A} {x : ℝ≥0}
    (ha : 0 ≤ a := by cfc_tac) :
    (x : ℝ) ∈ spectrum ℝ a ↔ x ∈ spectrum ℝ≥0 a 
goal: ↑x ∈ spectrum ℝ a ↔ x ∈ spectrum ℝ≥0 a