/-- Auxiliary definition for `rootSpaceWeightSpaceProduct`,
which is close to the deterministic timeout limit.
-/
def rootSpaceWeightSpaceProductAux {χ₁ χ₂ χ₃ : H → R} (hχ : χ₁ + χ₂ = χ₃) :
    rootSpace H χ₁ →ₗ[R] weightSpace M χ₂ →ₗ[R] weightSpace M χ₃ where
  toFun x :=
    { toFun := fun m =>
        ⟨⁅(x : L), (m : M)⁆, hχ ▸ lie_mem_weightSpace_of_mem_weightSpace x.property m.property⟩
      map_add' := fun m n => by simp only [LieSubmodule.coe_add, lie_add]; rfl
      map_smul' := fun t m => by
        dsimp only
        conv_lhs =>
          congr
          rw [LieSubmodule.coe_smul, lie_smul] }
  map_add' x y := by
    ext m
    simp only [AddSubmonoid.coe_add, Submodule.coe_toAddSubmonoid, add_lie, LinearMap.coe_mk,
      AddHom.coe_mk, LinearMap.add_apply, AddSubmonoid.mk_add_mk]
  map_smul' t x := by
    simp only [RingHom.id_apply]
    ext m
    

Proof state:
case h.a
R : Type u_1
L : Type u_2
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R ↥H
M : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : ↥H → R
hχ : χ₁ + χ₂ = χ₃
t : R
x : ↥↑(rootSpace H χ₁)
m : ↥↑(weightSpace M χ₂)
⊢ ↑({
          toAddHom :=
            { toFun := fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
              map_add' :=
                (_ :
                  ∀ (m n : ↥↑(weightSpace M χ₂)),
                    (fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                        (m + n) =
                      (fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) m +
                        (fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                          n) },
          map_smul' :=
            (_ :
              ∀ (t_1 : R) (m : ↥↑(weightSpace M χ₂)),
                AddHom.toFun
                    {
                      toFun := fun m =>
                        { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                      map_add' :=
                        (_ :
                          ∀ (m n : ↥↑(weightSpace M χ₂)),
                            (fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                (m + n) =
                              (fun m =>
                                    { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                  m +
                                (fun m =>
                                    { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                  n) }
                    (t_1 • m) =
                  (RingHom.id R) t_1 •
                    AddHom.toFun
                      {
                        toFun := fun m =>
                          { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                        map_add' :=
                          (_ :
                            ∀ (m n : ↥↑(weightSpace M χ₂)),
                              (fun m =>
                                    { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                  (m + n) =
                                (fun m =>
                                      { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                    m +
                                  (fun m =>
                                      { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                    n) }
                      m) }
        m) =
    ↑((t •
          {
            toAddHom :=
              { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                map_add' :=
                  (_ :
                    ∀ (m n : ↥↑(weightSpace M χ₂)),
                      (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) (m + n) =
                        (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) m +
                          (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) n) },
            map_smul' :=
              (_ :
                ∀ (t : R) (m : ↥↑(weightSpace M χ₂)),
                  AddHom.toFun
                      { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                        map_add' :=
                          (_ :
                            ∀ (m n : ↥↑(weightSpace M χ₂)),
                              (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) (m + n) =
                                (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) m +
                                  (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) n) }
                      (t • m) =
                    (RingHom.id R) t •
                      AddHom.toFun
                        { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                          map_add' :=
                            (_ :
                              ∀ (m n : ↥↑(weightSpace M χ₂)),
                                (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                    (m + n) =
                                  (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }) m +
                                    (fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) })
                                      n) }
                        m) })
        m)

Next tactic:
simp only [SetLike.val_smul, smul_lie, LinearMap.coe_mk, AddHom.coe_mk, LinearMap.smul_apply,
      SetLike.mk_smul_mk]