/-- 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
    simp only [fst_add, fst_inl, fst_inr, add_zero, map_add, snd_add, snd_inl, snd_inr,
      zero_add, φ.map_add]
    rw [add_add_add_comm]
  commutes' := fun r => by
    

Proof state:
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
r : R
⊢ OneHom.toFun
      (↑↑{
            toMonoidHom :=
              {
                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) },
            map_zero' := (_ : (algebraMap R C) 0 + φ 0 = 0),
            map_add' :=
              (_ :
                ∀ (x y : Unitization R 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) })
                      (x + y) =
                    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) })
                        x +
                      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) })
                        y) })
      ((algebraMap R (Unitization R A)) r) =
    (algebraMap R C) r

Next tactic:
simp only [algebraMap_eq_inl, fst_inl, snd_inl, φ.map_zero, add_zero]