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

Proof state:
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 χ₁)
⊢ {
      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) } =
    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) }

Next tactic:
ext m