/-- 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 where
  toFun := fun x => algebraMap R C x.fst + φ x.snd
  map_one' := by simp only [fst_one, map_one, snd_one, φ.map_zero, add_zero]
  map_mul' := fun x y => by
    induction' x using Unitization.ind with x_r x_a
    induction' y using Unitization.ind with y_r y_a
    simp only [fst_mul, fst_add, fst_inl, fst_inr, snd_mul, snd_add, snd_inl, snd_inr, add_zero,
      map_mul, zero_add, map_add, map_smul φ]
    rw [add_mul, mul_add, mul_add]
    rw [← Algebra.commutes _ (φ x_a)]
    simp only [Algebra.algebraMap_eq_smul_one, smul_one_mul, add_assoc]
  map_zero' := by simp only [fst_zero, map_zero, snd_zero, φ.map_zero, add_zero]
  map_add' := fun x y => by
    induction' x using Unitization.ind with x_r x_a
    induction' y using Unitization.ind with y_r y_a
    

Proof state:
case h.h
S : Type u_1
R : Type u_2
A : Type u_3
inst✝¹² : CommSemiring S
inst✝¹¹ : CommSemiring R
inst✝¹⁰ : NonUnitalSemiring A
inst✝⁹ : Module R A
inst✝⁸ : SMulCommClass R A A
inst✝⁷ : IsScalarTower R A A
B : Type u_4
inst✝⁶ : Semiring B
inst✝⁵ : Algebra S B
inst✝⁴ : Algebra S R
inst✝³ : DistribMulAction S A
inst✝² : IsScalarTower S R A
C : Type u_5
inst✝¹ : Semiring C
inst✝ : Algebra R C
φ : A →ₙₐ[R] C
x_r : R
x_a : A
y_r : R
y_a : A
⊢ OneHom.toFun
      (↑{
          toOneHom :=
            { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x), map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) },
          map_mul' :=
            (_ :
              ∀ (x y : Unitization R A),
                OneHom.toFun
                    { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                      map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                    (x * y) =
                  OneHom.toFun
                      { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                        map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                      x *
                    OneHom.toFun
                      { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                        map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                      y) })
      (inl x_r + ↑x_a + (inl y_r + ↑y_a)) =
    OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) },
            map_mul' :=
              (_ :
                ∀ (x y : Unitization R A),
                  OneHom.toFun
                      { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                        map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                      (x * y) =
                    OneHom.toFun
                        { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                          map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                        x *
                      OneHom.toFun
                        { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                          map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                        y) })
        (inl x_r + ↑x_a) +
      OneHom.toFun
        (↑{
            toOneHom :=
              { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) },
            map_mul' :=
              (_ :
                ∀ (x y : Unitization R A),
                  OneHom.toFun
                      { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                        map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                      (x * y) =
                    OneHom.toFun
                        { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                          map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                        x *
                      OneHom.toFun
                        { toFun := fun x => (algebraMap R C) (fst x) + φ (snd x),
                          map_one' := (_ : (algebraMap R C) 1 + φ 0 = 1) }
                        y) })
        (inl y_r + ↑y_a)

Next tactic:
simp only [fst_add, fst_inl, fst_inr, add_zero, map_add, snd_add, snd_inl, snd_inr,
      zero_add, φ.map_add]