File: Mathlib/Algebra/Algebra/Quasispectrum.lean

full_name: PreQuasiregular.val
code: /-- A type synonym for non-unital rings where an alternative monoid structure is introduced.
If `R` is a non-unital semiring, then `PreQuasiregular R` is equipped with the monoid structure
with binary operation `fun x y ↦ y + x + x * y` and identity `0`. Elements of `R` which are
invertible in this monoid satisfy the predicate `IsQuasiregular`. -/
structure PreQuasiregular (R : Type*) where
  /-- The value wrapped into a term of `PreQuasiregular`. -/
  val : R
goal: R

full_name: PreQuasiregular
code: /-- A type synonym for non-unital rings where an alternative monoid structure is introduced.
If `R` is a non-unital semiring, then `PreQuasiregular R` is equipped with the monoid structure
with binary operation `fun x y ↦ y + x + x * y` and identity `0`. Elements of `R` which are
invertible in this monoid satisfy the predicate `IsQuasiregular`. -/
structure PreQuasiregular (R : Type*) where
  /-- The value wrapped into a term of `PreQuasiregular`. -/
  val : R
goal: Type u_1

full_name: PreQuasiregular.equiv
code: /-- The identity map between `R` and `PreQuasiregular R`. -/
@[simps]
def equiv : R ≃ PreQuasiregular R 
goal: R ≃ PreQuasiregular R

full_name: PreQuasiregular.equiv_symm_apply
code: /-- The identity map between `R` and `PreQuasiregular R`. -/
@[simps]
def equiv : R ≃ PreQuasiregular R 
goal: PreQuasiregular.equiv.symm self = self.val

full_name: PreQuasiregular.equiv_apply_val
code: /-- The identity map between `R` and `PreQuasiregular R`. -/
@[simps]
def equiv : R ≃ PreQuasiregular R 
goal: (PreQuasiregular.equiv val).val = val

full_name: PreQuasiregular.instOne
code: instance instOne : One (PreQuasiregular R) 
goal: One (PreQuasiregular R)

full_name: PreQuasiregular.val_one
code: @[simp]
lemma val_one : (1 : PreQuasiregular R).val = 0 
goal: PreQuasiregular.val 1 = 0

full_name: PreQuasiregular.instMul
code: instance instMul : Mul (PreQuasiregular R) 
goal: Mul (PreQuasiregular R)

full_name: PreQuasiregular.val_mul
code: @[simp]
lemma val_mul (x y : PreQuasiregular R) : (x * y).val = y.val + x.val + x.val * y.val 
goal: (x * y).val = y.val + x.val + x.val * y.val

full_name: PreQuasiregular.instMonoid
code: instance instMonoid : Monoid (PreQuasiregular R) 
goal: Monoid (PreQuasiregular R)

full_name: PreQuasiregular.inv_add_add_mul_eq_zero
code: @[simp]
lemma inv_add_add_mul_eq_zero (u : (PreQuasiregular R)ˣ) :
    u⁻¹.val.val + u.val.val + u.val.val * u⁻¹.val.val = 0 
goal: (↑u⁻¹).val + (↑u).val + (↑u).val * (↑u⁻¹).val = 0

full_name: PreQuasiregular.add_inv_add_mul_eq_zero
code: @[simp]
lemma add_inv_add_mul_eq_zero (u : (PreQuasiregular R)ˣ) :
    u.val.val + u⁻¹.val.val + u⁻¹.val.val * u.val.val = 0 
goal: (↑u).val + (↑u⁻¹).val + (↑u⁻¹).val * (↑u).val = 0

full_name: Unitization.unitsFstOne
code: /-- The subgroup of the units of `Unitization R A` whose scalar part is `1`. -/
def unitsFstOne : Subgroup (Unitization R A)ˣ 
goal: Subgroup (Unitization R A)ˣ

full_name: Unitization.mem_unitsFstOne
code: @[simp]
lemma mem_unitsFstOne {x : (Unitization R A)ˣ} : x ∈ unitsFstOne R A ↔ x.val.fst = 1 
goal: x ∈ Unitization.unitsFstOne R A ↔ (↑x).fst = 1

full_name: Unitization.unitsFstOne_val_val_fst
code: @[simp]
lemma unitsFstOne_val_val_fst (x : (unitsFstOne R A)) : x.val.val.fst = 1 
goal: (↑↑x).fst = 1

full_name: Unitization.unitsFstOne_val_inv_val_fst
code: @[simp]
lemma unitsFstOne_val_inv_val_fst (x : (unitsFstOne R A)) : x.val⁻¹.val.fst = 1 
goal: (↑(↑x)⁻¹).fst = 1

full_name: Unitization.unitsFstOne_mulEquiv_quasiregular
code: /-- If `A` is a non-unital `R`-algebra, then the subgroup of units of `Unitization R A` whose
scalar part is `1 : R` (i.e., `Unitization.unitsFstOne`) is isomorphic to the group of units of
`PreQuasiregular A`. -/
@[simps]
def unitsFstOne_mulEquiv_quasiregular : unitsFstOne R A ≃* (PreQuasiregular A)ˣ 
goal: ↥(Unitization.unitsFstOne R A) ≃* (PreQuasiregular A)ˣ

full_name: Unitization.val_unitsFstOne_mulEquiv_quasiregular_apply
code: /-- If `A` is a non-unital `R`-algebra, then the subgroup of units of `Unitization R A` whose
scalar part is `1 : R` (i.e., `Unitization.unitsFstOne`) is isomorphic to the group of units of
`PreQuasiregular A`. -/
@[simps]
def unitsFstOne_mulEquiv_quasiregular : unitsFstOne R A ≃* (PreQuasiregular A)ˣ 
goal: ↑((Unitization.unitsFstOne_mulEquiv_quasiregular R) x) = PreQuasiregular.equiv (↑↑x).snd

full_name: Unitization.val_inv_unitsFstOne_mulEquiv_quasiregular_symm_apply_coe
code: /-- If `A` is a non-unital `R`-algebra, then the subgroup of units of `Unitization R A` whose
scalar part is `1 : R` (i.e., `Unitization.unitsFstOne`) is isomorphic to the group of units of
`PreQuasiregular A`. -/
@[simps]
def unitsFstOne_mulEquiv_quasiregular : unitsFstOne R A ≃* (PreQuasiregular A)ˣ 
goal: ↑(↑((Unitization.unitsFstOne_mulEquiv_quasiregular R).symm x))⁻¹ = 1 + ↑(PreQuasiregular.equiv.symm ↑x⁻¹)

full_name: Unitization.val_unitsFstOne_mulEquiv_quasiregular_symm_apply_coe
code: /-- If `A` is a non-unital `R`-algebra, then the subgroup of units of `Unitization R A` whose
scalar part is `1 : R` (i.e., `Unitization.unitsFstOne`) is isomorphic to the group of units of
`PreQuasiregular A`. -/
@[simps]
def unitsFstOne_mulEquiv_quasiregular : unitsFstOne R A ≃* (PreQuasiregular A)ˣ 
goal: ↑↑((Unitization.unitsFstOne_mulEquiv_quasiregular R).symm x) = 1 + ↑(PreQuasiregular.equiv.symm ↑x)

full_name: Unitization.val_inv_unitsFstOne_mulEquiv_quasiregular_apply
code: /-- If `A` is a non-unital `R`-algebra, then the subgroup of units of `Unitization R A` whose
scalar part is `1 : R` (i.e., `Unitization.unitsFstOne`) is isomorphic to the group of units of
`PreQuasiregular A`. -/
@[simps]
def unitsFstOne_mulEquiv_quasiregular : unitsFstOne R A ≃* (PreQuasiregular A)ˣ 
goal: ↑((Unitization.unitsFstOne_mulEquiv_quasiregular R) x)⁻¹ = PreQuasiregular.equiv (↑↑x⁻¹).snd

full_name: IsQuasiregular
code: /-- In a non-unital semiring `R`, an element `x : R` satisfies `IsQuasiregular` if it is a unit
under the monoid operation `fun x y ↦ y + x + x * y`. -/
def IsQuasiregular (x : R) : Prop 
goal: Prop

full_name: isQuasiregular_zero
code: @[simp]
lemma isQuasiregular_zero : IsQuasiregular 0 
goal: IsQuasiregular 0

full_name: isQuasiregular_iff
code: lemma isQuasiregular_iff {x : R} :
    IsQuasiregular x ↔ ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0 
goal: IsQuasiregular x ↔ ∃ y, y + x + x * y = 0 ∧ x + y + y * x = 0

full_name: IsQuasiregular.map
code: lemma IsQuasiregular.map {F R S : Type*} [NonUnitalSemiring R] [NonUnitalSemiring S]
    [FunLike F R S] [NonUnitalRingHomClass F R S] (f : F) {x : R} (hx : IsQuasiregular x) :
    IsQuasiregular (f x) 
goal: IsQuasiregular (f x)

full_name: IsQuasiregular.isUnit_one_add
code: lemma IsQuasiregular.isUnit_one_add {R : Type*} [Semiring R] {x : R} (hx : IsQuasiregular x) :
    IsUnit (1 + x) 
goal: IsUnit (1 + x)

full_name: isQuasiregular_iff_isUnit
code: lemma isQuasiregular_iff_isUnit {R : Type*} [Ring R] {x : R} :
    IsQuasiregular x ↔ IsUnit (1 + x) 
goal: IsQuasiregular x ↔ IsUnit (1 + x)

full_name: isQuasiregular_iff_isUnit'
code: lemma isQuasiregular_iff_isUnit' (R : Type*) {A : Type*} [CommSemiring R] [NonUnitalSemiring A]
    [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] {x : A} :
    IsQuasiregular x ↔ IsUnit (1 + x : Unitization R A) 
goal: IsQuasiregular x ↔ IsUnit (1 + ↑x)

full_name: quasispectrum
code: /-- If `A` is a non-unital `R`-algebra, the `R`-quasispectrum of `a : A` consists of those `r : R`
such that if `r` is invertible (in `R`), then `-(r⁻¹ • a)` is not quasiregular.

The quasispectrum is precisely the spectrum in the unitization when `R` is a commutative ring.
See `Unitization.quasispectrum_eq_spectrum_inr`. -/
def quasispectrum (a : A) : Set R 
goal: Set R

full_name: quasispectrum.not_isUnit_mem
code: lemma quasispectrum.not_isUnit_mem (a : A) {r : R} (hr : ¬ IsUnit r) : r ∈ quasispectrum R a 
goal: r ∈ quasispectrum R a

full_name: quasispectrum.zero_mem
code: @[simp]
lemma quasispectrum.zero_mem [Nontrivial R] (a : A) : 0 ∈ quasispectrum R a 
goal: 0 ∈ quasispectrum R a

full_name: quasispectrum.instZero
code: instance quasispectrum.instZero [Nontrivial R] (a : A) : Zero (quasispectrum R a) 
goal: Zero ↑(quasispectrum R a)

full_name: quasispectrum.coe_zero
code: @[simp]
lemma quasispectrum.coe_zero [Nontrivial R] (a : A) : (0 : quasispectrum R a) = (0 : R) 
goal: ↑0 = 0

full_name: quasispectrum.mem_of_not_quasiregular
code: lemma quasispectrum.mem_of_not_quasiregular (a : A) {r : Rˣ}
    (hr : ¬ IsQuasiregular (-(r⁻¹ • a))) : (r : R) ∈ quasispectrum R a 
goal: ↑r ∈ quasispectrum R a

full_name: quasispectrum_eq_spectrum_union
code: lemma quasispectrum_eq_spectrum_union (R : Type*) {A : Type*} [CommSemiring R]
    [Ring A] [Algebra R A] (a : A) : quasispectrum R a = spectrum R a ∪ {r : R | ¬ IsUnit r} 
goal: quasispectrum R a = spectrum R a ∪ {r | ¬IsUnit r}

full_name: spectrum_subset_quasispectrum
code: lemma spectrum_subset_quasispectrum (R : Type*) {A : Type*} [CommSemiring R] [Ring A] [Algebra R A]
    (a : A) : spectrum R a ⊆ quasispectrum R a 
goal: spectrum R a ⊆ quasispectrum R a

full_name: quasispectrum_eq_spectrum_union_zero
code: lemma quasispectrum_eq_spectrum_union_zero (R : Type*) {A : Type*} [Semifield R] [Ring A]
    [Algebra R A] (a : A) : quasispectrum R a = spectrum R a ∪ {0} 
goal: quasispectrum R a = spectrum R a ∪ {0}

full_name: mem_quasispectrum_iff
code: lemma mem_quasispectrum_iff {R A : Type*} [Semifield R] [Ring A]
    [Algebra R A] {a : A} {x : R} :
    x ∈ quasispectrum R a ↔ x = 0 ∨ x ∈ spectrum R a 
goal: x ∈ quasispectrum R a ↔ x = 0 ∨ x ∈ spectrum R a

full_name: Unitization.isQuasiregular_inr_iff
code: lemma isQuasiregular_inr_iff (a : A) :
    IsQuasiregular (a : Unitization R A) ↔ IsQuasiregular a 
goal: IsQuasiregular ↑a ↔ IsQuasiregular a

full_name: Unitization.zero_mem_spectrum_inr
code: lemma zero_mem_spectrum_inr (R S : Type*) {A : Type*} [CommSemiring R]
    [CommRing S] [Nontrivial S] [NonUnitalRing A] [Algebra R S] [Module S A] [IsScalarTower S A A]
    [SMulCommClass S A A] [Module R A] [IsScalarTower R S A] (a : A) :
    0 ∈ spectrum R (a : Unitization S A) 
goal: 0 ∈ spectrum R ↑a

full_name: Unitization.mem_spectrum_inr_of_not_isUnit
code: lemma mem_spectrum_inr_of_not_isUnit {R A : Type*} [CommRing R]
    [NonUnitalRing A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A]
    (a : A) (r : R) (hr : ¬ IsUnit r) : r ∈ spectrum R (a : Unitization R A) 
goal: r ∈ spectrum R ↑a

full_name: Unitization.quasispectrum_eq_spectrum_inr
code: lemma quasispectrum_eq_spectrum_inr (R : Type*) {A : Type*} [CommRing R] [Ring A]
    [Algebra R A] (a : A) : quasispectrum R a = spectrum R (a : Unitization R A) 
goal: quasispectrum R a = spectrum R ↑a

full_name: Unitization.quasispectrum_eq_spectrum_inr'
code: lemma quasispectrum_eq_spectrum_inr' (R S : Type*) {A : Type*} [Semifield R]
    [Field S] [NonUnitalRing A] [Algebra R S] [Module S A] [IsScalarTower S A A]
    [SMulCommClass S A A] [Module R A] [IsScalarTower R S A] (a : A) :
    quasispectrum R a = spectrum R (a : Unitization S A) 
goal: quasispectrum R a = spectrum R ↑a

full_name: NonnegSpectrumClass.quasispectrum_nonneg_of_nonneg
code: /-- A class for `𝕜`-algebras with a partial order where the ordering is compatible with the
(quasi)spectrum. -/
class NonnegSpectrumClass (𝕜 A : Type*) [OrderedCommSemiring 𝕜] [NonUnitalRing A] [PartialOrder A]
    [Module 𝕜 A] : Prop where
  quasispectrum_nonneg_of_nonneg : ∀ a : A, 0 ≤ a → ∀ x ∈ quasispectrum 𝕜 a, 0 ≤ x
goal: 0 ≤ a → ∀ x ∈ quasispectrum 𝕜 a, 0 ≤ x

full_name: NonnegSpectrumClass
code: /-- A class for `𝕜`-algebras with a partial order where the ordering is compatible with the
(quasi)spectrum. -/
class NonnegSpectrumClass (𝕜 A : Type*) [OrderedCommSemiring 𝕜] [NonUnitalRing A] [PartialOrder A]
    [Module 𝕜 A] : Prop where
  quasispectrum_nonneg_of_nonneg : ∀ a : A, 0 ≤ a → ∀ x ∈ quasispectrum 𝕜 a, 0 ≤ x
goal: Prop

full_name: NonnegSpectrumClass.iff_spectrum_nonneg
code: lemma iff_spectrum_nonneg {𝕜 A : Type*} [LinearOrderedSemifield 𝕜] [Ring A] [PartialOrder A]
    [Algebra 𝕜 A] : NonnegSpectrumClass 𝕜 A ↔ ∀ a : A, 0 ≤ a → ∀ x ∈ spectrum 𝕜 a, 0 ≤ x 
goal: NonnegSpectrumClass 𝕜 A ↔ ∀ (a : A), 0 ≤ a → ∀ x ∈ spectrum 𝕜 a, 0 ≤ x

full_name: spectrum_nonneg_of_nonneg
code: lemma spectrum_nonneg_of_nonneg {𝕜 A : Type*} [OrderedCommSemiring 𝕜] [Ring A] [PartialOrder A]
    [Algebra 𝕜 A] [NonnegSpectrumClass 𝕜 A] ⦃a : A⦄ (ha : 0 ≤ a) ⦃x : 𝕜⦄ (hx : x ∈ spectrum 𝕜 a) :
    0 ≤ x 
goal: 0 ≤ x

full_name: QuasispectrumRestricts.rightInvOn
code: /-- Given an element `a : A` of an `S`-algebra, where `S` is itself an `R`-algebra, we say that
the spectrum of `a` restricts via a function `f : S → R` if `f` is a left inverse of
`algebraMap R S`, and `f` is a right inverse of `algebraMap R S` on `spectrum S a`.

For example, when `f = Complex.re` (so `S := ℂ` and `R := ℝ`), `SpectrumRestricts a f` means that
the `ℂ`-spectrum of `a` is contained within `ℝ`. This arises naturally when `a` is selfadjoint
and `A` is a C⋆-algebra.

This is the property allows us to restrict a continuous functional calculus over `S` to a
continuous functional calculus over `R`. -/
structure QuasispectrumRestricts
    {R S A : Type*} [CommSemiring R] [CommSemiring S] [NonUnitalRing A]
    [Module R A] [Module S A] [Algebra R S] (a : A) (f : S → R) : Prop where
  /-- `f` is a right inverse of `algebraMap R S` when restricted to `quasispectrum S a`. -/
  rightInvOn : (quasispectrum S a).RightInvOn f (algebraMap R S)
  /-- `f` is a left inverse of `algebraMap R S`. -/
  left_inv : Function.LeftInverse f (algebraMap R S)
goal: Set.RightInvOn f (⇑(algebraMap R S)) (quasispectrum S a)

full_name: QuasispectrumRestricts
code: /-- Given an element `a : A` of an `S`-algebra, where `S` is itself an `R`-algebra, we say that
the spectrum of `a` restricts via a function `f : S → R` if `f` is a left inverse of
`algebraMap R S`, and `f` is a right inverse of `algebraMap R S` on `spectrum S a`.

For example, when `f = Complex.re` (so `S := ℂ` and `R := ℝ`), `SpectrumRestricts a f` means that
the `ℂ`-spectrum of `a` is contained within `ℝ`. This arises naturally when `a` is selfadjoint
and `A` is a C⋆-algebra.

This is the property allows us to restrict a continuous functional calculus over `S` to a
continuous functional calculus over `R`. -/
structure QuasispectrumRestricts
    {R S A : Type*} [CommSemiring R] [CommSemiring S] [NonUnitalRing A]
    [Module R A] [Module S A] [Algebra R S] (a : A) (f : S → R) : Prop where
  /-- `f` is a right inverse of `algebraMap R S` when restricted to `quasispectrum S a`. -/
  rightInvOn : (quasispectrum S a).RightInvOn f (algebraMap R S)
  /-- `f` is a left inverse of `algebraMap R S`. -/
  left_inv : Function.LeftInverse f (algebraMap R S)
goal: Prop

full_name: QuasispectrumRestricts.left_inv
code: /-- Given an element `a : A` of an `S`-algebra, where `S` is itself an `R`-algebra, we say that
the spectrum of `a` restricts via a function `f : S → R` if `f` is a left inverse of
`algebraMap R S`, and `f` is a right inverse of `algebraMap R S` on `spectrum S a`.

For example, when `f = Complex.re` (so `S := ℂ` and `R := ℝ`), `SpectrumRestricts a f` means that
the `ℂ`-spectrum of `a` is contained within `ℝ`. This arises naturally when `a` is selfadjoint
and `A` is a C⋆-algebra.

This is the property allows us to restrict a continuous functional calculus over `S` to a
continuous functional calculus over `R`. -/
structure QuasispectrumRestricts
    {R S A : Type*} [CommSemiring R] [CommSemiring S] [NonUnitalRing A]
    [Module R A] [Module S A] [Algebra R S] (a : A) (f : S → R) : Prop where
  /-- `f` is a right inverse of `algebraMap R S` when restricted to `quasispectrum S a`. -/
  rightInvOn : (quasispectrum S a).RightInvOn f (algebraMap R S)
  /-- `f` is a left inverse of `algebraMap R S`. -/
  left_inv : Function.LeftInverse f (algebraMap R S)
goal: Function.LeftInverse f ⇑(algebraMap R S)

full_name: quasispectrumRestricts_iff
code: lemma quasispectrumRestricts_iff
    {R S A : Type*} [CommSemiring R] [CommSemiring S] [NonUnitalRing A]
    [Module R A] [Module S A] [Algebra R S] (a : A) (f : S → R) :
    QuasispectrumRestricts a f ↔ (quasispectrum S a).RightInvOn f (algebraMap R S) ∧
      Function.LeftInverse f (algebraMap R S) 
goal: QuasispectrumRestricts a f ↔
  Set.RightInvOn f (⇑(algebraMap R S)) (quasispectrum S a) ∧ Function.LeftInverse f ⇑(algebraMap R S)

full_name: quasispectrum.algebraMap_mem_iff
code: @[simp]
theorem quasispectrum.algebraMap_mem_iff (S : Type*) {R A : Type*} [Semifield R] [Field S]
    [NonUnitalRing A] [Algebra R S] [Module S A] [IsScalarTower S A A]
    [SMulCommClass S A A] [Module R A] [IsScalarTower R S A] {a : A} {r : R} :
    algebraMap R S r ∈ quasispectrum S a ↔ r ∈ quasispectrum R a 
goal: (algebraMap R S) r ∈ quasispectrum S a ↔ r ∈ quasispectrum R a

full_name: quasispectrum.preimage_algebraMap
code: @[simp]
theorem quasispectrum.preimage_algebraMap (S : Type*) {R A : Type*} [Semifield R] [Field S]
    [NonUnitalRing A] [Algebra R S] [Module S A] [IsScalarTower S A A]
    [SMulCommClass S A A] [Module R A] [IsScalarTower R S A] {a : A} :
    algebraMap R S ⁻¹' quasispectrum S a = quasispectrum R a 
goal: ⇑(algebraMap R S) ⁻¹' quasispectrum S a = quasispectrum R a

full_name: QuasispectrumRestricts.map_zero
code: protected theorem map_zero (h : QuasispectrumRestricts a f) : f 0 = 0 
goal: f 0 = 0

full_name: QuasispectrumRestricts.of_subset_range_algebraMap
code: theorem of_subset_range_algebraMap (hf : f.LeftInverse (algebraMap R S))
    (h : quasispectrum S a ⊆ Set.range (algebraMap R S)) : QuasispectrumRestricts a f 
goal: QuasispectrumRestricts a f

full_name: QuasispectrumRestricts.algebraMap_image
code: theorem algebraMap_image : algebraMap R S '' quasispectrum R a = quasispectrum S a 
goal: ⇑(algebraMap R S) '' quasispectrum R a = quasispectrum S a

full_name: QuasispectrumRestricts.image
code: theorem image : f '' quasispectrum S a = quasispectrum R a 
goal: f '' quasispectrum S a = quasispectrum R a

full_name: QuasispectrumRestricts.apply_mem
code: theorem apply_mem {s : S} (hs : s ∈ quasispectrum S a) : f s ∈ quasispectrum R a 
goal: f s ∈ quasispectrum R a

full_name: QuasispectrumRestricts.subset_preimage
code: theorem subset_preimage : quasispectrum S a ⊆ f ⁻¹' quasispectrum R a 
goal: quasispectrum S a ⊆ f ⁻¹' quasispectrum R a

full_name: QuasispectrumRestricts.of_quasispectrum_eq
code: lemma of_quasispectrum_eq {a b : A} {f : S → R} (ha : QuasispectrumRestricts a f)
    (h : quasispectrum S a = quasispectrum S b) : QuasispectrumRestricts b f 
goal: QuasispectrumRestricts b f

full_name: QuasispectrumRestricts.comp
code: protected lemma comp {R₁ R₂ R₃ A : Type*} [Semifield R₁] [Field R₂] [Field R₃]
    [NonUnitalRing A] [Module R₁ A] [Module R₂ A] [Module R₃ A] [Algebra R₁ R₂] [Algebra R₂ R₃]
    [Algebra R₁ R₃] [IsScalarTower R₁ R₂ R₃] [IsScalarTower R₂ R₃ A] [IsScalarTower R₃ A A]
    [SMulCommClass R₃ A A] {a : A} {f : R₃ → R₂} {g : R₂ → R₁} {e : R₃ → R₁} (hfge : g ∘ f = e)
    (hf : QuasispectrumRestricts a f) (hg : QuasispectrumRestricts a g) :
    QuasispectrumRestricts a e 
goal: QuasispectrumRestricts a e

full_name: SpectrumRestricts
code: /-- A (reducible) alias of `QuasispectrumRestricts` which enforces stronger type class assumptions
on the types involved, as it's really intended for the `spectrum`. The separate definition also
allows for dot notation. -/
@[reducible]
def SpectrumRestricts
    {R S A : Type*} [Semifield R] [Semifield S] [Ring A]
    [Algebra R A] [Algebra S A] [Algebra R S] (a : A) (f : S → R) : Prop 
goal: Prop

full_name: SpectrumRestricts.rightInvOn
code: theorem rightInvOn (h : SpectrumRestricts a f) : (spectrum S a).RightInvOn f (algebraMap R S) 
goal: Set.RightInvOn f (⇑(algebraMap R S)) (spectrum S a)

full_name: SpectrumRestricts.of_rightInvOn
code: theorem of_rightInvOn (h₁ : Function.LeftInverse f (algebraMap R S))
    (h₂ : (spectrum S a).RightInvOn f (algebraMap R S)) : SpectrumRestricts a f 
goal: SpectrumRestricts a f

full_name: spectrumRestricts_iff
code: lemma _root_.spectrumRestricts_iff :
    SpectrumRestricts a f ↔ (spectrum S a).RightInvOn f (algebraMap R S) ∧
      Function.LeftInverse f (algebraMap R S) 
goal: SpectrumRestricts a f ↔ Set.RightInvOn f (⇑(algebraMap R S)) (spectrum S a) ∧ Function.LeftInverse f ⇑(algebraMap R S)

full_name: SpectrumRestricts.of_subset_range_algebraMap
code: theorem of_subset_range_algebraMap (hf : f.LeftInverse (algebraMap R S))
    (h : spectrum S a ⊆ Set.range (algebraMap R S)) : SpectrumRestricts a f 
goal: SpectrumRestricts a f

full_name: SpectrumRestricts.algebraMap_image
code: theorem algebraMap_image : algebraMap R S '' spectrum R a = spectrum S a 
goal: ⇑(algebraMap R S) '' spectrum R a = spectrum S a

full_name: SpectrumRestricts.image
code: theorem image : f '' spectrum S a = spectrum R a 
goal: f '' spectrum S a = spectrum R a

full_name: SpectrumRestricts.apply_mem
code: theorem apply_mem {s : S} (hs : s ∈ spectrum S a) : f s ∈ spectrum R a 
goal: f s ∈ spectrum R a

full_name: SpectrumRestricts.subset_preimage
code: theorem subset_preimage : spectrum S a ⊆ f ⁻¹' spectrum R a 
goal: spectrum S a ⊆ f ⁻¹' spectrum R a

full_name: SpectrumRestricts.of_spectrum_eq
code: lemma of_spectrum_eq {a b : A} {f : S → R} (ha : SpectrumRestricts a f)
    (h : spectrum S a = spectrum S b) : SpectrumRestricts b f 
goal: SpectrumRestricts b f

full_name: quasispectrumRestricts_iff_spectrumRestricts_inr
code: theorem quasispectrumRestricts_iff_spectrumRestricts_inr (S : Type*) {R 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] {a : A} {f : S → R} :
    QuasispectrumRestricts a f ↔ SpectrumRestricts (a : Unitization S A) f 
goal: QuasispectrumRestricts a f ↔ SpectrumRestricts (↑a) f

full_name: quasispectrumRestricts_iff_spectrumRestricts
code: theorem quasispectrumRestricts_iff_spectrumRestricts {R S A : Type*} [Semifield R] [Semifield S]
    [Ring A] [Algebra R S] [Algebra R A] [Algebra S A] {a : A} {f : S → R} :
    QuasispectrumRestricts a f ↔ SpectrumRestricts a f 
goal: QuasispectrumRestricts a f ↔ SpectrumRestricts a f