/-- The functor `X ↦ FreeLieAlgebra R X` from the category of types to the category of Lie
algebras over `R` is adjoint to the forgetful functor in the other direction. -/
def lift : (X → L) ≃ (FreeLieAlgebra R X →ₗ⁅R⁆ L) where
  toFun f :=
    { toFun := fun c => Quot.liftOn c (liftAux R f) (liftAux_spec R f)
      map_add' := by rintro ⟨a⟩ ⟨b⟩; rw [← liftAux_map_add]; rfl
      map_smul' := by rintro t ⟨a⟩; rw [← liftAux_map_smul]; rfl
      map_lie' := by rintro ⟨a⟩ ⟨b⟩; 

Proof state:
case mk.mk
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
f : X → L
x✝ : FreeLieAlgebra R X
a : lib R X
y✝ : FreeLieAlgebra R X
b : lib R X
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun c =>
                Quot.liftOn c ⇑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
              map_add' :=
                (_ :
                  ∀ (x y : FreeLieAlgebra R X),
                    (fun c =>
                          Quot.liftOn c ⇑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                        (x + y) =
                      (fun c =>
                            Quot.liftOn c ⇑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                          x +
                        (fun c =>
                            Quot.liftOn c ⇑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                          y) },
          map_smul' :=
            (_ :
              ∀ (t : R) (x : FreeLieAlgebra R X),
                AddHom.toFun
                    {
                      toFun := fun c =>
                        Quot.liftOn c ⇑(liftAux R f)
                          (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                      map_add' :=
                        (_ :
                          ∀ (x y : FreeLieAlgebra R X),
                            (fun c =>
                                  Quot.liftOn c ⇑(liftAux R f)
                                    (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                (x + y) =
                              (fun c =>
                                    Quot.liftOn c ⇑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                  x +
                                (fun c =>
                                    Quot.liftOn c ⇑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                  y) }
                    (t • x) =
                  (RingHom.id R) t •
                    AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ⇑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ⇑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    y) }
                      x) }.toAddHom
      ⁅Quot.mk (Rel R X) a, Quot.mk (Rel R X) b⁆ =
    ⁅AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun c =>
                  Quot.liftOn c ⇑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                map_add' :=
                  (_ :
                    ∀ (x y : FreeLieAlgebra R X),
                      (fun c =>
                            Quot.liftOn c ⇑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                          (x + y) =
                        (fun c =>
                              Quot.liftOn c ⇑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                            x +
                          (fun c =>
                              Quot.liftOn c ⇑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                            y) },
            map_smul' :=
              (_ :
                ∀ (t : R) (x : FreeLieAlgebra R X),
                  AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ⇑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ⇑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    y) }
                      (t • x) =
                    (RingHom.id R) t •
                      AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ⇑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ⇑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ⇑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                      y) }
                        x) }.toAddHom
        (Quot.mk (Rel R X) a),
      AddHom.toFun
        {
            toAddHom :=
              {
                toFun := fun c =>
                  Quot.liftOn c ⇑(liftAux R f) (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                map_add' :=
                  (_ :
                    ∀ (x y : FreeLieAlgebra R X),
                      (fun c =>
                            Quot.liftOn c ⇑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                          (x + y) =
                        (fun c =>
                              Quot.liftOn c ⇑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                            x +
                          (fun c =>
                              Quot.liftOn c ⇑(liftAux R f)
                                (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                            y) },
            map_smul' :=
              (_ :
                ∀ (t : R) (x : FreeLieAlgebra R X),
                  AddHom.toFun
                      {
                        toFun := fun c =>
                          Quot.liftOn c ⇑(liftAux R f)
                            (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                        map_add' :=
                          (_ :
                            ∀ (x y : FreeLieAlgebra R X),
                              (fun c =>
                                    Quot.liftOn c ⇑(liftAux R f)
                                      (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                  (x + y) =
                                (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    x +
                                  (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    y) }
                      (t • x) =
                    (RingHom.id R) t •
                      AddHom.toFun
                        {
                          toFun := fun c =>
                            Quot.liftOn c ⇑(liftAux R f)
                              (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b),
                          map_add' :=
                            (_ :
                              ∀ (x y : FreeLieAlgebra R X),
                                (fun c =>
                                      Quot.liftOn c ⇑(liftAux R f)
                                        (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                    (x + y) =
                                  (fun c =>
                                        Quot.liftOn c ⇑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                      x +
                                    (fun c =>
                                        Quot.liftOn c ⇑(liftAux R f)
                                          (_ : ∀ (a b : lib R X), Rel R X a b → (liftAux R f) a = (liftAux R f) b))
                                      y) }
                        x) }.toAddHom
        (Quot.mk (Rel R X) b)⁆

Next tactic:
rw [← liftAux_map_mul]