/-- A linear map between two Lie modules is a morphism of Lie modules iff the Lie algebra action
on it is trivial. -/
def maxTrivLinearMapEquivLieModuleHom : maxTrivSubmodule R L (M →ₗ[R] N) ≃ₗ[R] M →ₗ⁅R,L⁆ N where
  toFun f :=
    { toLinearMap := f.val
      map_lie' := fun {x m} => by
        have hf : ⁅x, f.val⁆ m = 0 := by rw [f.property x, LinearMap.zero_apply]
        rw [LieHom.lie_apply, sub_eq_zero, ← LinearMap.toFun_eq_coe] at hf; exact hf.symm}
  map_add' f g := by ext; simp
  map_smul' F G := by ext; simp
  invFun F := ⟨F, fun x => by ext; simp⟩
  left_inv f := by simp
  right_inv F := by 

Proof state:
R : Type u
L : Type v
M : Type w
N : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
F : M →ₗ⁅R,L⁆ N
⊢ AddHom.toFun
      {
          toAddHom :=
            {
              toFun := fun f =>
                { toLinearMap := ↑f,
                  map_lie' :=
                    (_ : ∀ {x : L} {m : M}, AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
              map_add' :=
                (_ :
                  ∀ (f g : ↥↑(maxTrivSubmodule R L (M →ₗ[R] N))),
                    (fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                        (f + g) =
                      (fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                          f +
                        (fun f =>
                            { toLinearMap := ↑f,
                              map_lie' :=
                                (_ :
                                  ∀ {x : L} {m : M},
                                    AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                          g) },
          map_smul' :=
            (_ :
              ∀ (F : R) (G : ↥↑(maxTrivSubmodule R L (M →ₗ[R] N))),
                AddHom.toFun
                    {
                      toFun := fun f =>
                        { toLinearMap := ↑f,
                          map_lie' :=
                            (_ :
                              ∀ {x : L} {m : M},
                                AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
                      map_add' :=
                        (_ :
                          ∀ (f g : ↥↑(maxTrivSubmodule R L (M →ₗ[R] N))),
                            (fun f =>
                                  { toLinearMap := ↑f,
                                    map_lie' :=
                                      (_ :
                                        ∀ {x : L} {m : M},
                                          AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                (f + g) =
                              (fun f =>
                                    { toLinearMap := ↑f,
                                      map_lie' :=
                                        (_ :
                                          ∀ {x : L} {m : M},
                                            AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                  f +
                                (fun f =>
                                    { toLinearMap := ↑f,
                                      map_lie' :=
                                        (_ :
                                          ∀ {x : L} {m : M},
                                            AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                  g) }
                    (F • G) =
                  (RingHom.id R) F •
                    AddHom.toFun
                      {
                        toFun := fun f =>
                          { toLinearMap := ↑f,
                            map_lie' :=
                              (_ :
                                ∀ {x : L} {m : M},
                                  AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) },
                        map_add' :=
                          (_ :
                            ∀ (f g : ↥↑(maxTrivSubmodule R L (M →ₗ[R] N))),
                              (fun f =>
                                    { toLinearMap := ↑f,
                                      map_lie' :=
                                        (_ :
                                          ∀ {x : L} {m : M},
                                            AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                  (f + g) =
                                (fun f =>
                                      { toLinearMap := ↑f,
                                        map_lie' :=
                                          (_ :
                                            ∀ {x : L} {m : M},
                                              AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                    f +
                                  (fun f =>
                                      { toLinearMap := ↑f,
                                        map_lie' :=
                                          (_ :
                                            ∀ {x : L} {m : M},
                                              AddHom.toFun (↑f).toAddHom ⁅x, m⁆ = ⁅x, AddHom.toFun (↑f).toAddHom m⁆) })
                                    g) }
                      G) }.toAddHom
      ((fun F => { val := ↑F, property := (_ : ∀ (x : L), ⁅x, ↑F⁆ = 0) }) F) =
    F

Next tactic:
simp