/-- 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 

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 : ↥↑(maxTrivSubmodule R L (M →ₗ[R] N))
⊢ (fun F => { val := ↑F, property := (_ : ∀ (x : L), ⁅x, ↑F⁆ = 0) })
      (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
        f) =
    f

Next tactic:
simp