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

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 χ₁)
⊢ AddHom.toFun
      {
        toFun := fun x =>
          {
            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) },
        map_add' :=
          (_ :
            ∀ (x y : ↥↑(rootSpace H χ₁)),
              (fun x =>
                    {
                      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) })
                  (x + y) =
                (fun x =>
                      {
                        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) })
                    x +
                  (fun x =>
                      {
                        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) })
                    y) }
      (t • x) =
    (RingHom.id R) t •
      AddHom.toFun
        {
          toFun := fun x =>
            {
              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) },
          map_add' :=
            (_ :
              ∀ (x y : ↥↑(rootSpace H χ₁)),
                (fun x =>
                      {
                        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) })
                    (x + y) =
                  (fun x =>
                        {
                          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) })
                      x +
                    (fun x =>
                        {
                          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) })
                      y) }
        x

Next tactic:
simp only [RingHom.id_apply]