File: Mathlib/Algebra/Algebra/Unitization.lean

full_name: Unitization
code: /-- The minimal unitization of a non-unital `R`-algebra `A`. This is just a type synonym for
`R × A`. -/
def Unitization (R A : Type*) 
goal: Type (max u_1 u_2)

full_name: Unitization.inl
code: /-- The canonical inclusion `R → Unitization R A`. -/
def inl [Zero A] (r : R) : Unitization R A 
goal: Unitization R A

full_name: Unitization.inr
code: /-- The canonical inclusion `A → Unitization R A`. -/
@[coe]
def inr [Zero R] (a : A) : Unitization R A 
goal: Unitization R A

full_name: Unitization.instCoeTCOfZero
code: instance [Zero R] : CoeTC A (Unitization R A) 
goal: CoeTC A (Unitization R A)

full_name: Unitization.fst
code: /-- The canonical projection `Unitization R A → R`. -/
def fst (x : Unitization R A) : R 
goal: R

full_name: Unitization.snd
code: /-- The canonical projection `Unitization R A → A`. -/
def snd (x : Unitization R A) : A 
goal: A

full_name: Unitization.ext
code: @[ext]
theorem ext {x y : Unitization R A} (h1 : x.fst = y.fst) (h2 : x.snd = y.snd) : x = y 
goal: x = y

full_name: Unitization.fst_inl
code: @[simp]
theorem fst_inl [Zero A] (r : R) : (inl r : Unitization R A).fst = r 
goal: (Unitization.inl r).fst = r

full_name: Unitization.snd_inl
code: @[simp]
theorem snd_inl [Zero A] (r : R) : (inl r : Unitization R A).snd = 0 
goal: (Unitization.inl r).snd = 0

full_name: Unitization.fst_inr
code: @[simp]
theorem fst_inr [Zero R] (a : A) : (a : Unitization R A).fst = 0 
goal: (↑a).fst = 0

full_name: Unitization.snd_inr
code: @[simp]
theorem snd_inr [Zero R] (a : A) : (a : Unitization R A).snd = a 
goal: (↑a).snd = a

full_name: Unitization.inl_injective
code: theorem inl_injective [Zero A] : Function.Injective (inl : R → Unitization R A) 
goal: Function.Injective Unitization.inl

full_name: Unitization.inr_injective
code: theorem inr_injective [Zero R] : Function.Injective ((↑) : A → Unitization R A) 
goal: Function.Injective Unitization.inr

full_name: Unitization.instNontrivialLeft
code: instance instNontrivialLeft {𝕜 A} [Nontrivial 𝕜] [Nonempty A] :
    Nontrivial (Unitization 𝕜 A) 
goal: Nontrivial (Unitization 𝕜 A)

full_name: Unitization.instNontrivialRight
code: instance instNontrivialRight {𝕜 A} [Nonempty 𝕜] [Nontrivial A] :
    Nontrivial (Unitization 𝕜 A) 
goal: Nontrivial (Unitization 𝕜 A)

full_name: Unitization.instCanLift
code: instance instCanLift [Zero R] : CanLift (Unitization R A) A inr (fun x ↦ x.fst = 0) 
goal: CanLift (Unitization R A) A Unitization.inr fun x => x.fst = 0

full_name: Unitization.instInhabited
code: instance instInhabited [Inhabited R] [Inhabited A] : Inhabited (Unitization R A) 
goal: Inhabited (Unitization R A)

full_name: Unitization.instZero
code: instance instZero [Zero R] [Zero A] : Zero (Unitization R A) 
goal: Zero (Unitization R A)

full_name: Unitization.instAdd
code: instance instAdd [Add R] [Add A] : Add (Unitization R A) 
goal: Add (Unitization R A)

full_name: Unitization.instNeg
code: instance instNeg [Neg R] [Neg A] : Neg (Unitization R A) 
goal: Neg (Unitization R A)

full_name: Unitization.instAddSemigroup
code: instance instAddSemigroup [AddSemigroup R] [AddSemigroup A] : AddSemigroup (Unitization R A) 
goal: AddSemigroup (Unitization R A)

full_name: Unitization.instAddZeroClass
code: instance instAddZeroClass [AddZeroClass R] [AddZeroClass A] : AddZeroClass (Unitization R A) 
goal: AddZeroClass (Unitization R A)

full_name: Unitization.instAddMonoid
code: instance instAddMonoid [AddMonoid R] [AddMonoid A] : AddMonoid (Unitization R A) 
goal: AddMonoid (Unitization R A)

full_name: Unitization.instAddGroup
code: instance instAddGroup [AddGroup R] [AddGroup A] : AddGroup (Unitization R A) 
goal: AddGroup (Unitization R A)

full_name: Unitization.instAddCommSemigroup
code: instance instAddCommSemigroup [AddCommSemigroup R] [AddCommSemigroup A] :
    AddCommSemigroup (Unitization R A) 
goal: AddCommSemigroup (Unitization R A)

full_name: Unitization.instAddCommMonoid
code: instance instAddCommMonoid [AddCommMonoid R] [AddCommMonoid A] : AddCommMonoid (Unitization R A) 
goal: AddCommMonoid (Unitization R A)

full_name: Unitization.instAddCommGroup
code: instance instAddCommGroup [AddCommGroup R] [AddCommGroup A] : AddCommGroup (Unitization R A) 
goal: AddCommGroup (Unitization R A)

full_name: Unitization.instSMul
code: instance instSMul [SMul S R] [SMul S A] : SMul S (Unitization R A) 
goal: SMul S (Unitization R A)

full_name: Unitization.instIsScalarTower
code: instance instIsScalarTower [SMul T R] [SMul T A] [SMul S R] [SMul S A] [SMul T S]
    [IsScalarTower T S R] [IsScalarTower T S A] : IsScalarTower T S (Unitization R A) 
goal: IsScalarTower T S (Unitization R A)

full_name: Unitization.instSMulCommClass
code: instance instSMulCommClass [SMul T R] [SMul T A] [SMul S R] [SMul S A] [SMulCommClass T S R]
    [SMulCommClass T S A] : SMulCommClass T S (Unitization R A) 
goal: SMulCommClass T S (Unitization R A)

full_name: Unitization.instIsCentralScalar
code: instance instIsCentralScalar [SMul S R] [SMul S A] [SMul Sᵐᵒᵖ R] [SMul Sᵐᵒᵖ A] [IsCentralScalar S R]
    [IsCentralScalar S A] : IsCentralScalar S (Unitization R A) 
goal: IsCentralScalar S (Unitization R A)

full_name: Unitization.instMulAction
code: instance instMulAction [Monoid S] [MulAction S R] [MulAction S A] : MulAction S (Unitization R A) 
goal: MulAction S (Unitization R A)

full_name: Unitization.instDistribMulAction
code: instance instDistribMulAction [Monoid S] [AddMonoid R] [AddMonoid A] [DistribMulAction S R]
    [DistribMulAction S A] : DistribMulAction S (Unitization R A) 
goal: DistribMulAction S (Unitization R A)

full_name: Unitization.instModule
code: instance instModule [Semiring S] [AddCommMonoid R] [AddCommMonoid A] [Module S R] [Module S A] :
    Module S (Unitization R A) 
goal: Module S (Unitization R A)

full_name: Unitization.addEquiv
code: /-- The identity map between `Unitization R A` and `R × A` as an `AddEquiv`. -/
def addEquiv [Add R] [Add A] : Unitization R A ≃+ R × A 
goal: Unitization R A ≃+ R × A

full_name: Unitization.fst_zero
code: @[simp]
theorem fst_zero [Zero R] [Zero A] : (0 : Unitization R A).fst = 0 
goal: Unitization.fst 0 = 0

full_name: Unitization.snd_zero
code: @[simp]
theorem snd_zero [Zero R] [Zero A] : (0 : Unitization R A).snd = 0 
goal: Unitization.snd 0 = 0

full_name: Unitization.fst_add
code: @[simp]
theorem fst_add [Add R] [Add A] (x₁ x₂ : Unitization R A) : (x₁ + x₂).fst = x₁.fst + x₂.fst 
goal: (x₁ + x₂).fst = x₁.fst + x₂.fst

full_name: Unitization.snd_add
code: @[simp]
theorem snd_add [Add R] [Add A] (x₁ x₂ : Unitization R A) : (x₁ + x₂).snd = x₁.snd + x₂.snd 
goal: (x₁ + x₂).snd = x₁.snd + x₂.snd

full_name: Unitization.fst_neg
code: @[simp]
theorem fst_neg [Neg R] [Neg A] (x : Unitization R A) : (-x).fst = -x.fst 
goal: (-x).fst = -x.fst

full_name: Unitization.snd_neg
code: @[simp]
theorem snd_neg [Neg R] [Neg A] (x : Unitization R A) : (-x).snd = -x.snd 
goal: (-x).snd = -x.snd

full_name: Unitization.fst_smul
code: @[simp]
theorem fst_smul [SMul S R] [SMul S A] (s : S) (x : Unitization R A) : (s • x).fst = s • x.fst 
goal: (s • x).fst = s • x.fst

full_name: Unitization.snd_smul
code: @[simp]
theorem snd_smul [SMul S R] [SMul S A] (s : S) (x : Unitization R A) : (s • x).snd = s • x.snd 
goal: (s • x).snd = s • x.snd

full_name: Unitization.inl_zero
code: @[simp]
theorem inl_zero [Zero R] [Zero A] : (inl 0 : Unitization R A) = 0 
goal: Unitization.inl 0 = 0

full_name: Unitization.inl_add
code: @[simp]
theorem inl_add [Add R] [AddZeroClass A] (r₁ r₂ : R) :
    (inl (r₁ + r₂) : Unitization R A) = inl r₁ + inl r₂ 
goal: Unitization.inl (r₁ + r₂) = Unitization.inl r₁ + Unitization.inl r₂

full_name: Unitization.inl_neg
code: @[simp]
theorem inl_neg [Neg R] [AddGroup A] (r : R) : (inl (-r) : Unitization R A) = -inl r 
goal: Unitization.inl (-r) = -Unitization.inl r

full_name: Unitization.inl_sub
code: @[simp]
theorem inl_sub [AddGroup R] [AddGroup A] (r₁ r₂ : R) :
    (inl (r₁ - r₂) : Unitization R A) = inl r₁ - inl r₂ 
goal: Unitization.inl (r₁ - r₂) = Unitization.inl r₁ - Unitization.inl r₂

full_name: Unitization.inl_smul
code: @[simp]
theorem inl_smul [Monoid S] [AddMonoid A] [SMul S R] [DistribMulAction S A] (s : S) (r : R) :
    (inl (s • r) : Unitization R A) = s • inl r 
goal: Unitization.inl (s • r) = s • Unitization.inl r

full_name: Unitization.inr_zero
code: @[simp]
theorem inr_zero [Zero R] [Zero A] : ↑(0 : A) = (0 : Unitization R A) 
goal: ↑0 = 0

full_name: Unitization.inr_add
code: @[simp]
theorem inr_add [AddZeroClass R] [Add A] (m₁ m₂ : A) : (↑(m₁ + m₂) : Unitization R A) = m₁ + m₂ 
goal: ↑(m₁ + m₂) = ↑m₁ + ↑m₂

full_name: Unitization.inr_neg
code: @[simp]
theorem inr_neg [AddGroup R] [Neg A] (m : A) : (↑(-m) : Unitization R A) = -m 
goal: ↑(-m) = -↑m

full_name: Unitization.inr_sub
code: @[simp]
theorem inr_sub [AddGroup R] [AddGroup A] (m₁ m₂ : A) : (↑(m₁ - m₂) : Unitization R A) = m₁ - m₂ 
goal: ↑(m₁ - m₂) = ↑m₁ - ↑m₂

full_name: Unitization.inr_smul
code: @[simp]
theorem inr_smul [Zero R] [Zero S] [SMulWithZero S R] [SMul S A] (r : S) (m : A) :
    (↑(r • m) : Unitization R A) = r • (m : Unitization R A) 
goal: ↑(r • m) = r • ↑m

full_name: Unitization.inl_fst_add_inr_snd_eq
code: theorem inl_fst_add_inr_snd_eq [AddZeroClass R] [AddZeroClass A] (x : Unitization R A) :
    inl x.fst + (x.snd : Unitization R A) = x 
goal: Unitization.inl x.fst + ↑x.snd = x

full_name: Unitization.ind
code: /-- To show a property hold on all `Unitization R A` it suffices to show it holds
on terms of the form `inl r + a`.

This can be used as `induction x`. -/
@[elab_as_elim, induction_eliminator, cases_eliminator]
theorem ind {R A} [AddZeroClass R] [AddZeroClass A] {P : Unitization R A → Prop}
    (inl_add_inr : ∀ (r : R) (a : A), P (inl r + (a : Unitization R A))) (x) : P x 
goal: P x

full_name: Unitization.linearMap_ext
code: /-- This cannot be marked `@[ext]` as it ends up being used instead of `LinearMap.prod_ext` when
working with `R × A`. -/
theorem linearMap_ext {N} [Semiring S] [AddCommMonoid R] [AddCommMonoid A] [AddCommMonoid N]
    [Module S R] [Module S A] [Module S N] ⦃f g : Unitization R A →ₗ[S] N⦄
    (hl : ∀ r, f (inl r) = g (inl r)) (hr : ∀ a : A, f a = g a) : f = g 
goal: f = g

full_name: Unitization.inrHom
code: /-- The canonical `R`-linear inclusion `A → Unitization R A`. -/
@[simps apply]
def inrHom [Semiring R] [AddCommMonoid A] [Module R A] : A →ₗ[R] Unitization R A 
goal: A →ₗ[R] Unitization R A

full_name: Unitization.inrHom_apply
code: /-- The canonical `R`-linear inclusion `A → Unitization R A`. -/
@[simps apply]
def inrHom [Semiring R] [AddCommMonoid A] [Module R A] : A →ₗ[R] Unitization R A 
goal: (Unitization.inrHom R A) a = ↑a

full_name: Unitization.sndHom
code: /-- The canonical `R`-linear projection `Unitization R A → A`. -/
@[simps apply]
def sndHom [Semiring R] [AddCommMonoid A] [Module R A] : Unitization R A →ₗ[R] A 
goal: Unitization R A →ₗ[R] A

full_name: Unitization.sndHom_apply
code: /-- The canonical `R`-linear projection `Unitization R A → A`. -/
@[simps apply]
def sndHom [Semiring R] [AddCommMonoid A] [Module R A] : Unitization R A →ₗ[R] A 
goal: (Unitization.sndHom R A) x = x.snd

full_name: Unitization.instOne
code: instance instOne [One R] [Zero A] : One (Unitization R A) 
goal: One (Unitization R A)

full_name: Unitization.instMul
code: instance instMul [Mul R] [Add A] [Mul A] [SMul R A] : Mul (Unitization R A) 
goal: Mul (Unitization R A)

full_name: Unitization.fst_one
code: @[simp]
theorem fst_one [One R] [Zero A] : (1 : Unitization R A).fst = 1 
goal: Unitization.fst 1 = 1

full_name: Unitization.snd_one
code: @[simp]
theorem snd_one [One R] [Zero A] : (1 : Unitization R A).snd = 0 
goal: Unitization.snd 1 = 0

full_name: Unitization.fst_mul
code: @[simp]
theorem fst_mul [Mul R] [Add A] [Mul A] [SMul R A] (x₁ x₂ : Unitization R A) :
    (x₁ * x₂).fst = x₁.fst * x₂.fst 
goal: (x₁ * x₂).fst = x₁.fst * x₂.fst

full_name: Unitization.snd_mul
code: @[simp]
theorem snd_mul [Mul R] [Add A] [Mul A] [SMul R A] (x₁ x₂ : Unitization R A) :
    (x₁ * x₂).snd = x₁.fst • x₂.snd + x₂.fst • x₁.snd + x₁.snd * x₂.snd 
goal: (x₁ * x₂).snd = x₁.fst • x₂.snd + x₂.fst • x₁.snd + x₁.snd * x₂.snd

full_name: Unitization.inl_one
code: @[simp]
theorem inl_one [One R] [Zero A] : (inl 1 : Unitization R A) = 1 
goal: Unitization.inl 1 = 1

full_name: Unitization.inl_mul
code: @[simp]
theorem inl_mul [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] (r₁ r₂ : R) :
    (inl (r₁ * r₂) : Unitization R A) = inl r₁ * inl r₂ 
goal: Unitization.inl (r₁ * r₂) = Unitization.inl r₁ * Unitization.inl r₂

full_name: Unitization.inl_mul_inl
code: theorem inl_mul_inl [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] (r₁ r₂ : R) :
    (inl r₁ * inl r₂ : Unitization R A) = inl (r₁ * r₂) 
goal: Unitization.inl r₁ * Unitization.inl r₂ = Unitization.inl (r₁ * r₂)

full_name: Unitization.inr_mul
code: @[simp]
theorem inr_mul [Semiring R] [AddCommMonoid A] [Mul A] [SMulWithZero R A] (a₁ a₂ : A) :
    (↑(a₁ * a₂) : Unitization R A) = a₁ * a₂ 
goal: ↑(a₁ * a₂) = ↑a₁ * ↑a₂

full_name: Unitization.inl_mul_inr
code: theorem inl_mul_inr [Semiring R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] (r : R)
    (a : A) : ((inl r : Unitization R A) * a) = ↑(r • a) 
goal: Unitization.inl r * ↑a = ↑(r • a)

full_name: Unitization.inr_mul_inl
code: theorem inr_mul_inl [Semiring R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] (r : R)
    (a : A) : a * (inl r : Unitization R A) = ↑(r • a) 
goal: ↑a * Unitization.inl r = ↑(r • a)

full_name: Unitization.instMulOneClass
code: instance instMulOneClass [Monoid R] [NonUnitalNonAssocSemiring A] [DistribMulAction R A] :
    MulOneClass (Unitization R A) 
goal: MulOneClass (Unitization R A)

full_name: Unitization.instNonAssocSemiring
code: instance instNonAssocSemiring [Semiring R] [NonUnitalNonAssocSemiring A] [Module R A] :
    NonAssocSemiring (Unitization R A) 
goal: NonAssocSemiring (Unitization R A)

full_name: Unitization.instMonoid
code: instance instMonoid [CommMonoid R] [NonUnitalSemiring A] [DistribMulAction R A]
    [IsScalarTower R A A] [SMulCommClass R A A] : Monoid (Unitization R A) 
goal: Monoid (Unitization R A)

full_name: Unitization.instCommMonoid
code: instance instCommMonoid [CommMonoid R] [NonUnitalCommSemiring A] [DistribMulAction R A]
    [IsScalarTower R A A] [SMulCommClass R A A] : CommMonoid (Unitization R A) 
goal: CommMonoid (Unitization R A)

full_name: Unitization.instSemiring
code: instance instSemiring [CommSemiring R] [NonUnitalSemiring A] [Module R A] [IsScalarTower R A A]
    [SMulCommClass R A A] : Semiring (Unitization R A) 
goal: Semiring (Unitization R A)

full_name: Unitization.instCommSemiring
code: instance instCommSemiring [CommSemiring R] [NonUnitalCommSemiring A] [Module R A]
    [IsScalarTower R A A] [SMulCommClass R A A] : CommSemiring (Unitization R A) 
goal: CommSemiring (Unitization R A)

full_name: Unitization.instNonAssocRing
code: instance instNonAssocRing [CommRing R] [NonUnitalNonAssocRing A] [Module R A] :
    NonAssocRing (Unitization R A) 
goal: NonAssocRing (Unitization R A)

full_name: Unitization.instRing
code: instance instRing [CommRing R] [NonUnitalRing A] [Module R A] [IsScalarTower R A A]
    [SMulCommClass R A A] : Ring (Unitization R A) 
goal: Ring (Unitization R A)

full_name: Unitization.instCommRing
code: instance instCommRing [CommRing R] [NonUnitalCommRing A] [Module R A] [IsScalarTower R A A]
    [SMulCommClass R A A] : CommRing (Unitization R A) 
goal: CommRing (Unitization R A)

full_name: Unitization.inlRingHom_apply
code: /-- The canonical inclusion of rings `R →+* Unitization R A`. -/
@[simps apply]
def inlRingHom [Semiring R] [NonUnitalSemiring A] [Module R A] : R →+* Unitization R A 
goal: (Unitization.inlRingHom R A) r = Unitization.inl r

full_name: Unitization.inlRingHom
code: /-- The canonical inclusion of rings `R →+* Unitization R A`. -/
@[simps apply]
def inlRingHom [Semiring R] [NonUnitalSemiring A] [Module R A] : R →+* Unitization R A 
goal: R →+* Unitization R A

full_name: Unitization.instStar
code: instance instStar [Star R] [Star A] : Star (Unitization R A) 
goal: Star (Unitization R A)

full_name: Unitization.fst_star
code: @[simp]
theorem fst_star [Star R] [Star A] (x : Unitization R A) : (star x).fst = star x.fst 
goal: (star x).fst = star x.fst

full_name: Unitization.snd_star
code: @[simp]
theorem snd_star [Star R] [Star A] (x : Unitization R A) : (star x).snd = star x.snd 
goal: (star x).snd = star x.snd

full_name: Unitization.inl_star
code: @[simp]
theorem inl_star [Star R] [AddMonoid A] [StarAddMonoid A] (r : R) :
    inl (star r) = star (inl r : Unitization R A) 
goal: Unitization.inl (star r) = star (Unitization.inl r)

full_name: Unitization.inr_star
code: @[simp]
theorem inr_star [AddMonoid R] [StarAddMonoid R] [Star A] (a : A) :
    ↑(star a) = star (a : Unitization R A) 
goal: ↑(star a) = star ↑a

full_name: Unitization.instStarAddMonoid
code: instance instStarAddMonoid [AddMonoid R] [AddMonoid A] [StarAddMonoid R] [StarAddMonoid A] :
    StarAddMonoid (Unitization R A) 
goal: StarAddMonoid (Unitization R A)

full_name: Unitization.instStarModule
code: instance instStarModule [CommSemiring R] [StarRing R] [AddCommMonoid A] [StarAddMonoid A]
    [Module R A] [StarModule R A] : StarModule R (Unitization R A) 
goal: StarModule R (Unitization R A)

full_name: Unitization.instStarRing
code: instance instStarRing [CommSemiring R] [StarRing R] [NonUnitalNonAssocSemiring A] [StarRing A]
    [Module R A] [StarModule R A] :
    StarRing (Unitization R A) 
goal: StarRing (Unitization R A)

full_name: Unitization.instAlgebra
code: instance instAlgebra : Algebra S (Unitization R A) 
goal: Algebra S (Unitization R A)

full_name: Unitization.algebraMap_eq_inl_comp
code: theorem algebraMap_eq_inl_comp : ⇑(algebraMap S (Unitization R A)) = inl ∘ algebraMap S R 
goal: ⇑(algebraMap S (Unitization R A)) = Unitization.inl ∘ ⇑(algebraMap S R)

full_name: Unitization.algebraMap_eq_inlRingHom_comp
code: theorem algebraMap_eq_inlRingHom_comp :
    algebraMap S (Unitization R A) = (inlRingHom R A).comp (algebraMap S R) 
goal: algebraMap S (Unitization R A) = (Unitization.inlRingHom R A).comp (algebraMap S R)

full_name: Unitization.algebraMap_eq_inl
code: theorem algebraMap_eq_inl : ⇑(algebraMap R (Unitization R A)) = inl 
goal: ⇑(algebraMap R (Unitization R A)) = Unitization.inl

full_name: Unitization.algebraMap_eq_inlRingHom
code: theorem algebraMap_eq_inlRingHom : algebraMap R (Unitization R A) = inlRingHom R A 
goal: algebraMap R (Unitization R A) = Unitization.inlRingHom R A

full_name: Unitization.fstHom
code: /-- The canonical `R`-algebra projection `Unitization R A → R`. -/
@[simps]
def fstHom : Unitization R A →ₐ[R] R 
goal: Unitization R A →ₐ[R] R

full_name: Unitization.fstHom_apply
code: /-- The canonical `R`-algebra projection `Unitization R A → R`. -/
@[simps]
def fstHom : Unitization R A →ₐ[R] R 
goal: (Unitization.fstHom R A) x = x.fst

full_name: Unitization.inrNonUnitalAlgHom_apply
code: /-- The coercion from a non-unital `R`-algebra `A` to its unitization `Unitization R A`
realized as a non-unital algebra homomorphism. -/
@[simps]
def inrNonUnitalAlgHom (R A : Type*) [CommSemiring R] [NonUnitalSemiring A] [Module R A] :
    A →ₙₐ[R] Unitization R A 
goal: (Unitization.inrNonUnitalAlgHom R A) a = ↑a

full_name: Unitization.inrNonUnitalAlgHom
code: /-- The coercion from a non-unital `R`-algebra `A` to its unitization `Unitization R A`
realized as a non-unital algebra homomorphism. -/
@[simps]
def inrNonUnitalAlgHom (R A : Type*) [CommSemiring R] [NonUnitalSemiring A] [Module R A] :
    A →ₙₐ[R] Unitization R A 
goal: A →ₙₐ[R] Unitization R A

full_name: Unitization.inrNonUnitalAlgHom_toFun
code: /-- The coercion from a non-unital `R`-algebra `A` to its unitization `Unitization R A`
realized as a non-unital algebra homomorphism. -/
@[simps]
def inrNonUnitalAlgHom (R A : Type*) [CommSemiring R] [NonUnitalSemiring A] [Module R A] :
    A →ₙₐ[R] Unitization R A 
goal: (Unitization.inrNonUnitalAlgHom R A) a = ↑a

full_name: Unitization.inrNonUnitalStarAlgHom
code: /-- The coercion from a non-unital `R`-algebra `A` to its unitization `unitization R A`
realized as a non-unital star algebra homomorphism. -/
@[simps!]
def inrNonUnitalStarAlgHom (R A : Type*) [CommSemiring R] [StarAddMonoid R]
    [NonUnitalSemiring A] [Star A] [Module R A] :
    A →⋆ₙₐ[R] Unitization R A 
goal: A →⋆ₙₐ[R] Unitization R A

full_name: Unitization.inrNonUnitalStarAlgHom_apply
code: /-- The coercion from a non-unital `R`-algebra `A` to its unitization `unitization R A`
realized as a non-unital star algebra homomorphism. -/
@[simps!]
def inrNonUnitalStarAlgHom (R A : Type*) [CommSemiring R] [StarAddMonoid R]
    [NonUnitalSemiring A] [Star A] [Module R A] :
    A →⋆ₙₐ[R] Unitization R A 
goal: (Unitization.inrNonUnitalStarAlgHom R A) a = ↑a

full_name: Unitization.inrRangeEquiv
code: /-- The star algebra equivalence obtained by restricting `Unitization.inrNonUnitalStarAlgHom`
to its range. -/
@[simps!]
def inrRangeEquiv (R A : Type*) [CommSemiring R] [StarAddMonoid R] [NonUnitalSemiring A]
    [Star A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] :
    A ≃⋆ₐ[R] NonUnitalStarAlgHom.range (inrNonUnitalStarAlgHom R A) 
goal: A ≃⋆ₐ[R] ↥(NonUnitalStarAlgHom.range (Unitization.inrNonUnitalStarAlgHom R A))

full_name: Unitization.inrRangeEquiv_apply_coe
code: /-- The star algebra equivalence obtained by restricting `Unitization.inrNonUnitalStarAlgHom`
to its range. -/
@[simps!]
def inrRangeEquiv (R A : Type*) [CommSemiring R] [StarAddMonoid R] [NonUnitalSemiring A]
    [Star A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] :
    A ≃⋆ₐ[R] NonUnitalStarAlgHom.range (inrNonUnitalStarAlgHom R A) 
goal: ↑((Unitization.inrRangeEquiv R A) a) = ↑(Unitization.inrNonUnitalStarAlgHom R A) a

full_name: Unitization.inrRangeEquiv_symm_apply
code: /-- The star algebra equivalence obtained by restricting `Unitization.inrNonUnitalStarAlgHom`
to its range. -/
@[simps!]
def inrRangeEquiv (R A : Type*) [CommSemiring R] [StarAddMonoid R] [NonUnitalSemiring A]
    [Star A] [Module R A] [IsScalarTower R A A] [SMulCommClass R A A] :
    A ≃⋆ₐ[R] NonUnitalStarAlgHom.range (inrNonUnitalStarAlgHom R A) 
goal: ∀ (a : ↥(NonUnitalStarAlgHom.range (Unitization.inrNonUnitalStarAlgHom R A))),
  (Unitization.inrRangeEquiv R A).symm a = (↑a).snd

full_name: Unitization.algHom_ext
code: theorem algHom_ext {F : Type*}
    [FunLike F (Unitization R A) B] [AlgHomClass F S (Unitization R A) B] {φ ψ : F}
    (h : ∀ a : A, φ a = ψ a)
    (h' : ∀ r, φ (algebraMap R (Unitization R A) r) = ψ (algebraMap R (Unitization R A) r)) :
    φ = ψ 
goal: φ = ψ

full_name: Unitization.algHom_ext''
code: lemma algHom_ext'' {F : Type*}
    [FunLike F (Unitization R A) C] [AlgHomClass F R (Unitization R A) C] {φ ψ : F}
    (h : ∀ a : A, φ a = ψ a) : φ = ψ 
goal: φ = ψ

full_name: Unitization.algHom_ext'
code: /-- See note [partially-applied ext lemmas] -/
@[ext 1100]
theorem algHom_ext' {φ ψ : Unitization R A →ₐ[R] C}
    (h :
      φ.toNonUnitalAlgHom.comp (inrNonUnitalAlgHom R A) =
        ψ.toNonUnitalAlgHom.comp (inrNonUnitalAlgHom R A)) :
    φ = ψ 
goal: φ = ψ

full_name: NonUnitalAlgHom.toAlgHom
code: /-- A non-unital algebra homomorphism from `A` into a unital `R`-algebra `C` lifts to a unital
algebra homomorphism from the unitization into `C`. This is extended to an `Equiv` in
`Unitization.lift` and that should be used instead. This declaration only exists for performance
reasons. -/
@[simps]
def _root_.NonUnitalAlgHom.toAlgHom (φ : A →ₙₐ[R] C) : Unitization R A →ₐ[R] C 
goal: Unitization R A →ₐ[R] C

full_name: NonUnitalAlgHom.toAlgHom_apply
code: /-- A non-unital algebra homomorphism from `A` into a unital `R`-algebra `C` lifts to a unital
algebra homomorphism from the unitization into `C`. This is extended to an `Equiv` in
`Unitization.lift` and that should be used instead. This declaration only exists for performance
reasons. -/
@[simps]
def _root_.NonUnitalAlgHom.toAlgHom (φ : A →ₙₐ[R] C) : Unitization R A →ₐ[R] C 
goal: φ.toAlgHom x = (algebraMap R C) x.fst + φ x.snd

full_name: Unitization.lift_apply
code: /-- Non-unital algebra homomorphisms from `A` into a unital `R`-algebra `C` lift uniquely to
`Unitization R A →ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def lift : (A →ₙₐ[R] C) ≃ (Unitization R A →ₐ[R] C) 
goal: Unitization.lift φ = φ.toAlgHom

full_name: Unitization.lift
code: /-- Non-unital algebra homomorphisms from `A` into a unital `R`-algebra `C` lift uniquely to
`Unitization R A →ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def lift : (A →ₙₐ[R] C) ≃ (Unitization R A →ₐ[R] C) 
goal: (A →ₙₐ[R] C) ≃ (Unitization R A →ₐ[R] C)

full_name: Unitization.lift_apply_apply
code: /-- Non-unital algebra homomorphisms from `A` into a unital `R`-algebra `C` lift uniquely to
`Unitization R A →ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def lift : (A →ₙₐ[R] C) ≃ (Unitization R A →ₐ[R] C) 
goal: (Unitization.lift φ) x = (algebraMap R C) x.fst + φ x.snd

full_name: Unitization.lift_symm_apply
code: /-- Non-unital algebra homomorphisms from `A` into a unital `R`-algebra `C` lift uniquely to
`Unitization R A →ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def lift : (A →ₙₐ[R] C) ≃ (Unitization R A →ₐ[R] C) 
goal: Unitization.lift.symm φ = (NonUnitalAlgHomClass.toNonUnitalAlgHom φ).comp (Unitization.inrNonUnitalAlgHom R A)

full_name: Unitization.lift_symm_apply_apply
code: theorem lift_symm_apply_apply (φ : Unitization R A →ₐ[R] C) (a : A) :
    Unitization.lift.symm φ a = φ a 
goal: (Unitization.lift.symm φ) a = φ ↑a

full_name: NonUnitalAlgHom.toAlgHom_zero
code: @[simp]
lemma _root_.NonUnitalAlgHom.toAlgHom_zero :
    ⇑(0 : A →ₙₐ[R] R).toAlgHom = Unitization.fst 
goal: ⇑(NonUnitalAlgHom.toAlgHom 0) = Unitization.fst

full_name: Unitization.starAlgHom_ext
code: /-- See note [partially-applied ext lemmas] -/
@[ext]
theorem starAlgHom_ext {φ ψ : Unitization R A →⋆ₐ[R] C}
    (h : (φ : Unitization R A →⋆ₙₐ[R] C).comp (Unitization.inrNonUnitalStarAlgHom R A) =
      (ψ : Unitization R A →⋆ₙₐ[R] C).comp (Unitization.inrNonUnitalStarAlgHom R A)) :
    φ = ψ 
goal: φ = ψ

full_name: Unitization.starLift
code: /-- Non-unital star algebra homomorphisms from `A` into a unital star `R`-algebra `C` lift uniquely
to `Unitization R A →⋆ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def starLift : (A →⋆ₙₐ[R] C) ≃ (Unitization R A →⋆ₐ[R] C) 
goal: (A →⋆ₙₐ[R] C) ≃ (Unitization R A →⋆ₐ[R] C)

full_name: Unitization.starLift_symm_apply
code: /-- Non-unital star algebra homomorphisms from `A` into a unital star `R`-algebra `C` lift uniquely
to `Unitization R A →⋆ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def starLift : (A →⋆ₙₐ[R] C) ≃ (Unitization R A →⋆ₐ[R] C) 
goal: Unitization.starLift.symm φ = φ.toNonUnitalStarAlgHom.comp (Unitization.inrNonUnitalStarAlgHom R A)

full_name: Unitization.starLift_apply_apply
code: /-- Non-unital star algebra homomorphisms from `A` into a unital star `R`-algebra `C` lift uniquely
to `Unitization R A →⋆ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def starLift : (A →⋆ₙₐ[R] C) ≃ (Unitization R A →⋆ₐ[R] C) 
goal: (Unitization.starLift φ) x = (algebraMap R C) x.fst + φ x.snd

full_name: Unitization.starLift_apply
code: /-- Non-unital star algebra homomorphisms from `A` into a unital star `R`-algebra `C` lift uniquely
to `Unitization R A →⋆ₐ[R] C`. This is the universal property of the unitization. -/
@[simps! apply symm_apply apply_apply]
def starLift : (A →⋆ₙₐ[R] C) ≃ (Unitization R A →⋆ₐ[R] C) 
goal: Unitization.starLift φ = { toAlgHom := φ.toAlgHom, map_star' := ⋯ }

full_name: Unitization.starLift_symm_apply_apply
code: @[simp high, nolint simpNF]
theorem starLift_symm_apply_apply (φ : Unitization R A →ₐ[R] C) (a : A) :
    Unitization.lift.symm φ a = φ a 
goal: (Unitization.lift.symm φ) a = φ ↑a

full_name: Unitization.isStarNormal_inr
code: @[simp]
lemma isStarNormal_inr : IsStarNormal (a : Unitization R A) ↔ IsStarNormal a 
goal: IsStarNormal ↑a ↔ IsStarNormal a

full_name: Unitization.instIsStarNormal
code: instance instIsStarNormal (a : A) [IsStarNormal a] :
    IsStarNormal (a : Unitization R A) 
goal: IsStarNormal ↑a

full_name: Unitization.isSelfAdjoint_inr
code: @[simp]
lemma isSelfAdjoint_inr : IsSelfAdjoint (a : Unitization R A) ↔ IsSelfAdjoint a 
goal: IsSelfAdjoint ↑a ↔ IsSelfAdjoint a

full_name: IsSelfAdjoint.inr
code: lemma _root_.IsSelfAdjoint.inr (ha : IsSelfAdjoint a) : IsSelfAdjoint (a : Unitization R A) 
goal: IsSelfAdjoint ↑a