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

Proof state:
case h
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 : R
G : ↥↑(maxTrivSubmodule R L (M →ₗ[R] N))
m✝ : M
⊢ (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))
      m✝ =
    ((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)
      m✝

Next tactic:
simp