/-- Intermediate result of `CliffordAlgebraQuaternion.equiv`: clifford algebras over
`CliffordAlgebraQuaternion.Q` can be converted to `ℍ[R,c₁,c₂]`. -/
def toQuaternion : CliffordAlgebra (Q c₁ c₂) →ₐ[R] ℍ[R,c₁,c₂] :=
  CliffordAlgebra.lift (Q c₁ c₂)
    ⟨{  toFun := fun v => (⟨0, v.1, v.2, 0⟩ : ℍ[R,c₁,c₂])
        map_add' := fun v₁ v₂ => by simp
        map_smul' := fun r v => by dsimp; rw [mul_zero]; rfl }, fun v => by
      

Proof state:
R : Type u_1
inst✝ : CommRing R
c₁ c₂ : R
v : R × R
⊢ {
          toAddHom :=
            { toFun := fun v => { re := 0, imI := v.1, imJ := v.2, imK := 0 },
              map_add' :=
                (_ :
                  ∀ (v₁ v₂ : R × R),
                    { re := 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 } =
                      { re := 0 + 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 + 0 }) },
          map_smul' :=
            (_ :
              ∀ (r : R) (v : R × R),
                AddHom.toFun
                    { toFun := fun v => { re := 0, imI := v.1, imJ := v.2, imK := 0 },
                      map_add' :=
                        (_ :
                          ∀ (v₁ v₂ : R × R),
                            { re := 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 } =
                              { re := 0 + 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 + 0 }) }
                    (r • v) =
                  (RingHom.id R) r •
                    AddHom.toFun
                      { toFun := fun v => { re := 0, imI := v.1, imJ := v.2, imK := 0 },
                        map_add' :=
                          (_ :
                            ∀ (v₁ v₂ : R × R),
                              { re := 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 } =
                                { re := 0 + 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 + 0 }) }
                      v) }
        v *
      {
          toAddHom :=
            { toFun := fun v => { re := 0, imI := v.1, imJ := v.2, imK := 0 },
              map_add' :=
                (_ :
                  ∀ (v₁ v₂ : R × R),
                    { re := 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 } =
                      { re := 0 + 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 + 0 }) },
          map_smul' :=
            (_ :
              ∀ (r : R) (v : R × R),
                AddHom.toFun
                    { toFun := fun v => { re := 0, imI := v.1, imJ := v.2, imK := 0 },
                      map_add' :=
                        (_ :
                          ∀ (v₁ v₂ : R × R),
                            { re := 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 } =
                              { re := 0 + 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 + 0 }) }
                    (r • v) =
                  (RingHom.id R) r •
                    AddHom.toFun
                      { toFun := fun v => { re := 0, imI := v.1, imJ := v.2, imK := 0 },
                        map_add' :=
                          (_ :
                            ∀ (v₁ v₂ : R × R),
                              { re := 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 } =
                                { re := 0 + 0, imI := v₁.1 + v₂.1, imJ := v₁.2 + v₂.2, imK := 0 + 0 }) }
                      v) }
        v =
    (algebraMap R ℍ[R,c₁,c₂]) ((Q c₁ c₂) v)

Next tactic:
dsimp