[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ m ∈ preWeightSpace M χ ↔ ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
[PROOFSTEP]
simp [preWeightSpace]
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
x : L
⊢ ∃ k, preWeightSpace M 0 ≤ LinearMap.ker (↑(toEndomorphism R L M) x ^ k)
[PROOFSTEP]
use(toEndomorphism R L M x).maximalGeneralizedEigenspaceIndex 0
[GOAL]
case h
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
x : L
⊢ preWeightSpace M 0 ≤
    LinearMap.ker
      (↑(toEndomorphism R L M) x ^ Module.End.maximalGeneralizedEigenspaceIndex (↑(toEndomorphism R L M) x) 0)
[PROOFSTEP]
simp only [← Module.End.generalizedEigenspace_zero, preWeightSpace, Pi.zero_apply, iInf_le, ←
  (toEndomorphism R L M x).maximalGeneralizedEigenspace_eq]
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
⊢ LinearMap.range (LinearMap.comp (↑g) (TensorProduct.mapIncl (preWeightSpace M₁ χ₁) (preWeightSpace M₂ χ₂))) ≤
    preWeightSpace M₃ (χ₁ + χ₂)
[PROOFSTEP]
intro m₃
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
m₃ : M₃
⊢ m₃ ∈ LinearMap.range (LinearMap.comp (↑g) (TensorProduct.mapIncl (preWeightSpace M₁ χ₁) (preWeightSpace M₂ χ₂))) →
    m₃ ∈ preWeightSpace M₃ (χ₁ + χ₂)
[PROOFSTEP]
simp only [LieModuleHom.coe_toLinearMap, Pi.add_apply, Function.comp_apply, mem_preWeightSpace, LinearMap.coe_comp,
  TensorProduct.mapIncl, exists_imp, LinearMap.mem_range]
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
m₃ : M₃
⊢ ∀ (x : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }),
    ↑g (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂))) x) =
        m₃ →
      ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k) m₃ = 0
[PROOFSTEP]
rintro t rfl x
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            t)) =
      0
[PROOFSTEP]
let F : Module.End R M₃ :=
  toEndomorphism R L M₃ x -
    (χ₁ x + χ₂ x) •
      ↑1
          -- The goal is linear in `t` so use induction to reduce to the case that `t` is a pure tensor.
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            t)) =
      0
[PROOFSTEP]
refine t.induction_on ?_ ?_ ?_
[GOAL]
case refine_1
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            0)) =
      0
[PROOFSTEP]
use 0
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
⊢ ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ 0)
      (↑g
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
          0)) =
    0
[PROOFSTEP]
simp only [LinearMap.map_zero, LieModuleHom.map_zero]
[GOAL]
case refine_2
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
⊢ ∀ (x_1 : { x // x ∈ preWeightSpace M₁ χ₁ }) (y : { x // x ∈ preWeightSpace M₂ χ₂ }),
    ∃ k,
      ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
          (↑g
            (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
              (x_1 ⊗ₜ[R] y))) =
        0
case refine_3
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
⊢ ∀ (x_1 y : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }),
    (∃ k,
        ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
            (↑g
              (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁))
                    (Submodule.subtype (preWeightSpace M₂ χ₂)))
                x_1)) =
          0) →
      (∃ k,
          ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
              (↑g
                (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁))
                      (Submodule.subtype (preWeightSpace M₂ χ₂)))
                  y)) =
            0) →
        ∃ k,
          ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
              (↑g
                (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁))
                      (Submodule.subtype (preWeightSpace M₂ χ₂)))
                  (x_1 + y))) =
            0
[PROOFSTEP]
swap
[GOAL]
case refine_3
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
⊢ ∀ (x_1 y : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }),
    (∃ k,
        ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
            (↑g
              (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁))
                    (Submodule.subtype (preWeightSpace M₂ χ₂)))
                x_1)) =
          0) →
      (∃ k,
          ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
              (↑g
                (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁))
                      (Submodule.subtype (preWeightSpace M₂ χ₂)))
                  y)) =
            0) →
        ∃ k,
          ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
              (↑g
                (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁))
                      (Submodule.subtype (preWeightSpace M₂ χ₂)))
                  (x_1 + y))) =
            0
[PROOFSTEP]
rintro t₁ t₂ ⟨k₁, hk₁⟩ ⟨k₂, hk₂⟩
[GOAL]
case refine_3.intro.intro
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
t₁ t₂ : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
k₁ : ℕ
hk₁ :
  ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k₁)
      (↑g
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
          t₁)) =
    0
k₂ : ℕ
hk₂ :
  ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k₂)
      (↑g
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
          t₂)) =
    0
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            (t₁ + t₂))) =
      0
[PROOFSTEP]
use max k₁ k₂
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
t₁ t₂ : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
k₁ : ℕ
hk₁ :
  ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k₁)
      (↑g
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
          t₁)) =
    0
k₂ : ℕ
hk₂ :
  ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k₂)
      (↑g
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
          t₂)) =
    0
⊢ ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ max k₁ k₂)
      (↑g
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
          (t₁ + t₂))) =
    0
[PROOFSTEP]
simp only [LieModuleHom.map_add, LinearMap.map_add, LinearMap.pow_map_zero_of_le (le_max_left k₁ k₂) hk₁,
  LinearMap.pow_map_zero_of_le (le_max_right k₁ k₂) hk₂, add_zero]
  -- Now the main argument: pure tensors.
[GOAL]
case refine_2
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
⊢ ∀ (x_1 : { x // x ∈ preWeightSpace M₁ χ₁ }) (y : { x // x ∈ preWeightSpace M₂ χ₂ }),
    ∃ k,
      ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
          (↑g
            (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
              (x_1 ⊗ₜ[R] y))) =
        0
[PROOFSTEP]
rintro ⟨m₁, hm₁⟩
  ⟨m₂, hm₂⟩
      --  change ∃ k, (F ^ k) ((g : M₁ ⊗[R] M₂ →ₗ[R] M₃) (m₁ ⊗ₜ m₂)) = 0
        -- Eliminate `g` from the picture.
[GOAL]
case refine_2.mk.mk
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            ({ val := m₁, property := hm₁ } ⊗ₜ[R] { val := m₂, property := hm₂ }))) =
      0
[PROOFSTEP]
let f₁ : Module.End R (M₁ ⊗[R] M₂) := (toEndomorphism R L M₁ x - χ₁ x • ↑1).rTensor M₂
[GOAL]
case refine_2.mk.mk
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            ({ val := m₁, property := hm₁ } ⊗ₜ[R] { val := m₂, property := hm₂ }))) =
      0
[PROOFSTEP]
let f₂ : Module.End R (M₁ ⊗[R] M₂) := (toEndomorphism R L M₂ x - χ₂ x • ↑1).lTensor M₁
[GOAL]
case refine_2.mk.mk
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            ({ val := m₁, property := hm₁ } ⊗ₜ[R] { val := m₂, property := hm₂ }))) =
      0
[PROOFSTEP]
have h_comm_square : F ∘ₗ ↑g = (g : M₁ ⊗[R] M₂ →ₗ[R] M₃).comp (f₁ + f₂) :=
  by
  ext m₁ m₂;
  simp only [← g.map_lie x (m₁ ⊗ₜ m₂), add_smul, sub_tmul, tmul_sub, smul_tmul, lie_tmul_right, tmul_smul,
    toEndomorphism_apply_apply, LieModuleHom.map_smul, LinearMap.one_apply, LieModuleHom.coe_toLinearMap,
    LinearMap.smul_apply, Function.comp_apply, LinearMap.coe_comp, LinearMap.rTensor_tmul, LieModuleHom.map_add,
    LinearMap.add_apply, LieModuleHom.map_sub, LinearMap.sub_apply, LinearMap.lTensor_tmul,
    AlgebraTensorModule.curry_apply, curry_apply, LinearMap.toFun_eq_coe, LinearMap.coe_restrictScalars]
  abel
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
⊢ LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
[PROOFSTEP]
ext m₁ m₂
[GOAL]
case a.h.h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁✝ : M₁
hm₁ : m₁✝ ∈ preWeightSpace M₁ χ₁
m₂✝ : M₂
hm₂ : m₂✝ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
m₁ : M₁
m₂ : M₂
⊢ ↑(↑(AlgebraTensorModule.curry (LinearMap.comp F ↑g)) m₁) m₂ =
    ↑(↑(AlgebraTensorModule.curry (LinearMap.comp (↑g) (f₁ + f₂))) m₁) m₂
[PROOFSTEP]
simp only [← g.map_lie x (m₁ ⊗ₜ m₂), add_smul, sub_tmul, tmul_sub, smul_tmul, lie_tmul_right, tmul_smul,
  toEndomorphism_apply_apply, LieModuleHom.map_smul, LinearMap.one_apply, LieModuleHom.coe_toLinearMap,
  LinearMap.smul_apply, Function.comp_apply, LinearMap.coe_comp, LinearMap.rTensor_tmul, LieModuleHom.map_add,
  LinearMap.add_apply, LieModuleHom.map_sub, LinearMap.sub_apply, LinearMap.lTensor_tmul,
  AlgebraTensorModule.curry_apply, curry_apply, LinearMap.toFun_eq_coe, LinearMap.coe_restrictScalars]
[GOAL]
case a.h.h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁✝ : M₁
hm₁ : m₁✝ ∈ preWeightSpace M₁ χ₁
m₂✝ : M₂
hm₂ : m₂✝ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
m₁ : M₁
m₂ : M₂
⊢ ↑g (⁅x, m₁⁆ ⊗ₜ[R] m₂) + ↑g (m₁ ⊗ₜ[R] ⁅x, m₂⁆) - (χ₁ x • ↑g (m₁ ⊗ₜ[R] m₂) + χ₂ x • ↑g (m₁ ⊗ₜ[R] m₂)) =
    ↑g (⁅x, m₁⁆ ⊗ₜ[R] m₂) - χ₁ x • ↑g (m₁ ⊗ₜ[R] m₂) + (↑g (m₁ ⊗ₜ[R] ⁅x, m₂⁆) - χ₂ x • ↑g (m₁ ⊗ₜ[R] m₂))
[PROOFSTEP]
abel
[GOAL]
case a.h.h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁✝ : M₁
hm₁ : m₁✝ ∈ preWeightSpace M₁ χ₁
m₂✝ : M₂
hm₂ : m₂✝ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
m₁ : M₁
m₂ : M₂
⊢ ↑g (⁅x, m₁⁆ ⊗ₜ[R] m₂) + ↑g (m₁ ⊗ₜ[R] ⁅x, m₂⁆) - (χ₁ x • ↑g (m₁ ⊗ₜ[R] m₂) + χ₂ x • ↑g (m₁ ⊗ₜ[R] m₂)) =
    ↑g (⁅x, m₁⁆ ⊗ₜ[R] m₂) - χ₁ x • ↑g (m₁ ⊗ₜ[R] m₂) + (↑g (m₁ ⊗ₜ[R] ⁅x, m₂⁆) - χ₂ x • ↑g (m₁ ⊗ₜ[R] m₂))
[PROOFSTEP]
abel
[GOAL]
case refine_2.mk.mk
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            ({ val := m₁, property := hm₁ } ⊗ₜ[R] { val := m₂, property := hm₂ }))) =
      0
[PROOFSTEP]
rsuffices ⟨k, hk⟩ : ∃ k : ℕ, ((f₁ + f₂) ^ k) (m₁ ⊗ₜ m₂) = 0
[GOAL]
case refine_2.mk.mk.intro
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
k : ℕ
hk : ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
⊢ ∃ k,
    ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
        (↑g
          (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
            ({ val := m₁, property := hm₁ } ⊗ₜ[R] { val := m₂, property := hm₂ }))) =
      0
[PROOFSTEP]
use k
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
k : ℕ
hk : ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
⊢ ↑((↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1) ^ k)
      (↑g
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace M₁ χ₁)) (Submodule.subtype (preWeightSpace M₂ χ₂)))
          ({ val := m₁, property := hm₁ } ⊗ₜ[R] { val := m₂, property := hm₂ }))) =
    0
[PROOFSTEP]
change (F ^ k) (g.toLinearMap (m₁ ⊗ₜ[R] m₂)) = 0
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
k : ℕ
hk : ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
⊢ ↑(F ^ k) (↑↑g (m₁ ⊗ₜ[R] m₂)) = 0
[PROOFSTEP]
rw [← LinearMap.comp_apply, LinearMap.commute_pow_left_of_commute h_comm_square, LinearMap.comp_apply, hk,
  LinearMap.map_zero]
  -- Unpack the information we have about `m₁`, `m₂`.
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
hm₁ : m₁ ∈ preWeightSpace M₁ χ₁
m₂ : M₂
hm₂ : m₂ ∈ preWeightSpace M₂ χ₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
⊢ ∃ k, ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
simp only [mem_preWeightSpace] at hm₁ hm₂
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
⊢ ∃ k, ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
obtain ⟨k₁, hk₁⟩ := hm₁ x
[GOAL]
case intro
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
⊢ ∃ k, ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
obtain ⟨k₂, hk₂⟩ := hm₂ x
[GOAL]
case intro.intro
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
⊢ ∃ k, ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
have hf₁ : (f₁ ^ k₁) (m₁ ⊗ₜ m₂) = 0 := by simp only [hk₁, zero_tmul, LinearMap.rTensor_tmul, LinearMap.rTensor_pow]
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
⊢ ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
simp only [hk₁, zero_tmul, LinearMap.rTensor_tmul, LinearMap.rTensor_pow]
[GOAL]
case intro.intro
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
⊢ ∃ k, ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
have hf₂ : (f₂ ^ k₂) (m₁ ⊗ₜ m₂) = 0 := by
  simp only [hk₂, tmul_zero, LinearMap.lTensor_tmul, LinearMap.lTensor_pow]
    -- It's now just an application of the binomial theorem.
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
⊢ ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
simp only [hk₂, tmul_zero, LinearMap.lTensor_tmul, LinearMap.lTensor_pow]
  -- It's now just an application of the binomial theorem.
[GOAL]
case intro.intro
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
⊢ ∃ k, ↑((f₁ + f₂) ^ k) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
use k₁ + k₂ - 1
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
⊢ ↑((f₁ + f₂) ^ (k₁ + k₂ - 1)) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
have hf_comm : Commute f₁ f₂ := by
  ext m₁ m₂
  simp only [LinearMap.mul_apply, LinearMap.rTensor_tmul, LinearMap.lTensor_tmul, AlgebraTensorModule.curry_apply,
    LinearMap.toFun_eq_coe, LinearMap.lTensor_tmul, curry_apply, LinearMap.coe_restrictScalars]
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
⊢ Commute f₁ f₂
[PROOFSTEP]
ext m₁ m₂
[GOAL]
case a.h.h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁✝ : M₁
m₂✝ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁✝ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂✝ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁✝ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂✝ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁✝ ⊗ₜ[R] m₂✝) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁✝ ⊗ₜ[R] m₂✝) = 0
m₁ : M₁
m₂ : M₂
⊢ ↑(↑(AlgebraTensorModule.curry (f₁ * f₂)) m₁) m₂ = ↑(↑(AlgebraTensorModule.curry (f₂ * f₁)) m₁) m₂
[PROOFSTEP]
simp only [LinearMap.mul_apply, LinearMap.rTensor_tmul, LinearMap.lTensor_tmul, AlgebraTensorModule.curry_apply,
  LinearMap.toFun_eq_coe, LinearMap.lTensor_tmul, curry_apply, LinearMap.coe_restrictScalars]
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
⊢ ↑((f₁ + f₂) ^ (k₁ + k₂ - 1)) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
rw [hf_comm.add_pow']
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
⊢ ↑(∑ m in Finset.Nat.antidiagonal (k₁ + k₂ - 1), Nat.choose (k₁ + k₂ - 1) m.fst • (f₁ ^ m.fst * f₂ ^ m.snd))
      (m₁ ⊗ₜ[R] m₂) =
    0
[PROOFSTEP]
simp only [TensorProduct.mapIncl, Submodule.subtype_apply, Finset.sum_apply, Submodule.coe_mk, LinearMap.coeFn_sum,
  TensorProduct.map_tmul, LinearMap.smul_apply]
  -- The required sum is zero because each individual term is zero.
[GOAL]
case h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
⊢ ∑ x_1 in Finset.Nat.antidiagonal (k₁ + k₂ - 1),
      Nat.choose (k₁ + k₂ - 1) x_1.fst •
        ↑(LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ x_1.fst *
              LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ x_1.snd)
          (m₁ ⊗ₜ[R] m₂) =
    0
[PROOFSTEP]
apply Finset.sum_eq_zero
[GOAL]
case h.h
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
⊢ ∀ (x_1 : ℕ × ℕ),
    x_1 ∈ Finset.Nat.antidiagonal (k₁ + k₂ - 1) →
      Nat.choose (k₁ + k₂ - 1) x_1.fst •
          ↑(LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ x_1.fst *
                LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ x_1.snd)
            (m₁ ⊗ₜ[R] m₂) =
        0
[PROOFSTEP]
rintro ⟨i, j⟩ hij
[GOAL]
case h.h.mk
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (k₁ + k₂ - 1)
⊢ Nat.choose (k₁ + k₂ - 1) (i, j).fst •
      ↑(LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ (i, j).fst *
            LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ (i, j).snd)
        (m₁ ⊗ₜ[R] m₂) =
    0
[PROOFSTEP]
suffices (f₁ ^ i * f₂ ^ j) (m₁ ⊗ₜ m₂) = 0 by rw [this]; apply smul_zero
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (k₁ + k₂ - 1)
this : ↑(f₁ ^ i * f₂ ^ j) (m₁ ⊗ₜ[R] m₂) = 0
⊢ Nat.choose (k₁ + k₂ - 1) (i, j).fst •
      ↑(LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ (i, j).fst *
            LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ (i, j).snd)
        (m₁ ⊗ₜ[R] m₂) =
    0
[PROOFSTEP]
rw [this]
[GOAL]
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (k₁ + k₂ - 1)
this : ↑(f₁ ^ i * f₂ ^ j) (m₁ ⊗ₜ[R] m₂) = 0
⊢ Nat.choose (k₁ + k₂ - 1) (i, j).fst • 0 = 0
[PROOFSTEP]
apply smul_zero
[GOAL]
case h.h.mk
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (k₁ + k₂ - 1)
⊢ ↑(f₁ ^ i * f₂ ^ j) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
cases' Nat.le_or_le_of_add_eq_add_pred (Finset.Nat.mem_antidiagonal.mp hij) with hi hj
[GOAL]
case h.h.mk.inl
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (k₁ + k₂ - 1)
hi : k₁ ≤ (i, j).fst
⊢ ↑(f₁ ^ i * f₂ ^ j) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
rw [(hf_comm.pow_pow i j).eq, LinearMap.mul_apply, LinearMap.pow_map_zero_of_le hi hf₁, LinearMap.map_zero]
[GOAL]
case h.h.mk.inr
R : Type u
L : Type v
inst✝¹⁹ : CommRing R
inst✝¹⁸ : LieRing L
inst✝¹⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝¹⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝¹⁵ : AddCommGroup M
inst✝¹⁴ : Module R M
inst✝¹³ : LieRingModule L M
inst✝¹² : LieModule R L M
M₁ : Type w₁
M₂ : Type w₂
M₃ : Type w₃
inst✝¹¹ : AddCommGroup M₁
inst✝¹⁰ : Module R M₁
inst✝⁹ : LieRingModule L M₁
inst✝⁸ : LieModule R L M₁
inst✝⁷ : AddCommGroup M₂
inst✝⁶ : Module R M₂
inst✝⁵ : LieRingModule L M₂
inst✝⁴ : LieModule R L M₂
inst✝³ : AddCommGroup M₃
inst✝² : Module R M₃
inst✝¹ : LieRingModule L M₃
inst✝ : LieModule R L M₃
g : M₁ ⊗[R] M₂ →ₗ⁅R,L⁆ M₃
χ₁ χ₂ : L → R
t : { x // x ∈ preWeightSpace M₁ χ₁ } ⊗[R] { x // x ∈ preWeightSpace M₂ χ₂ }
x : L
F : Module.End R M₃ := ↑(toEndomorphism R L M₃) x - (χ₁ x + χ₂ x) • 1
m₁ : M₁
m₂ : M₂
f₁ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.rTensor M₂ (↑(toEndomorphism R L M₁) x - χ₁ x • 1)
f₂ : Module.End R (M₁ ⊗[R] M₂) := LinearMap.lTensor M₁ (↑(toEndomorphism R L M₂) x - χ₂ x • 1)
h_comm_square : LinearMap.comp F ↑g = LinearMap.comp (↑g) (f₁ + f₂)
hm₁ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k) m₁ = 0
hm₂ : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k) m₂ = 0
k₁ : ℕ
hk₁ : ↑((↑(toEndomorphism R L M₁) x - χ₁ x • 1) ^ k₁) m₁ = 0
k₂ : ℕ
hk₂ : ↑((↑(toEndomorphism R L M₂) x - χ₂ x • 1) ^ k₂) m₂ = 0
hf₁ : ↑(f₁ ^ k₁) (m₁ ⊗ₜ[R] m₂) = 0
hf₂ : ↑(f₂ ^ k₂) (m₁ ⊗ₜ[R] m₂) = 0
hf_comm : Commute f₁ f₂
i j : ℕ
hij : (i, j) ∈ Finset.Nat.antidiagonal (k₁ + k₂ - 1)
hj : k₂ ≤ (i, j).snd
⊢ ↑(f₁ ^ i * f₂ ^ j) (m₁ ⊗ₜ[R] m₂) = 0
[PROOFSTEP]
rw [LinearMap.mul_apply, LinearMap.pow_map_zero_of_le hj hf₂, LinearMap.map_zero]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : L → R
x : L
m : M
hx : x ∈ preWeightSpace L χ₁
hm : m ∈ preWeightSpace M χ₂
⊢ ⁅x, m⁆ ∈ preWeightSpace M (χ₁ + χ₂)
[PROOFSTEP]
apply LieModule.weight_vector_multiplication L L M M (toModuleHom R L M) χ₁ χ₂
[GOAL]
case a
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : L → R
x : L
m : M
hx : x ∈ preWeightSpace L χ₁
hm : m ∈ preWeightSpace M χ₂
⊢ ⁅x, m⁆ ∈
    LinearMap.range
      (LinearMap.comp (↑(toModuleHom R L M)) (TensorProduct.mapIncl (preWeightSpace L χ₁) (preWeightSpace M χ₂)))
[PROOFSTEP]
simp only [LieModuleHom.coe_toLinearMap, Function.comp_apply, LinearMap.coe_comp, TensorProduct.mapIncl,
  LinearMap.mem_range]
[GOAL]
case a
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : L → R
x : L
m : M
hx : x ∈ preWeightSpace L χ₁
hm : m ∈ preWeightSpace M χ₂
⊢ ∃ y,
    ↑(toModuleHom R L M)
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace L χ₁)) (Submodule.subtype (preWeightSpace M χ₂))) y) =
      ⁅x, m⁆
[PROOFSTEP]
use⟨x, hx⟩ ⊗ₜ ⟨m, hm⟩
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : L → R
x : L
m : M
hx : x ∈ preWeightSpace L χ₁
hm : m ∈ preWeightSpace M χ₂
⊢ ↑(toModuleHom R L M)
      (↑(TensorProduct.map (Submodule.subtype (preWeightSpace L χ₁)) (Submodule.subtype (preWeightSpace M χ₂)))
        ({ val := x, property := hx } ⊗ₜ[R] { val := m, property := hm })) =
    ⁅x, m⁆
[PROOFSTEP]
simp only [Submodule.subtype_apply, toModuleHom_apply, TensorProduct.map_tmul]
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
src✝ : Submodule R M := preWeightSpace M χ
x✝ : L
m✝ : M
hm :
  m✝ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ⁅x✝, m✝⁆ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
dsimp only
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
src✝ : Submodule R M := preWeightSpace M χ
x✝ : L
m✝ : M
hm :
  m✝ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ⁅x✝, m✝⁆ ∈ (preWeightSpace M χ).toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
rw [← zero_add χ]
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
src✝ : Submodule R M := preWeightSpace M χ
x✝ : L
m✝ : M
hm :
  m✝ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ⁅x✝, m✝⁆ ∈ (preWeightSpace M (0 + χ)).toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
refine lie_mem_preWeightSpace_of_mem_preWeightSpace ?_ hm
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
src✝ : Submodule R M := preWeightSpace M χ
x✝ : L
m✝ : M
hm :
  m✝ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ x✝ ∈ preWeightSpace L 0
[PROOFSTEP]
suffices preWeightSpace L (0 : L → R) = ⊤ by simp only [this, Submodule.mem_top]
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
src✝ : Submodule R M := preWeightSpace M χ
x✝ : L
m✝ : M
hm :
  m✝ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
this : preWeightSpace L 0 = ⊤
⊢ x✝ ∈ preWeightSpace L 0
[PROOFSTEP]
simp only [this, Submodule.mem_top]
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
src✝ : Submodule R M := preWeightSpace M χ
x✝ : L
m✝ : M
hm :
  m✝ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ preWeightSpace L 0 = ⊤
[PROOFSTEP]
exact LieAlgebra.iInf_max_gen_zero_eigenspace_eq_top_of_nilpotent R L
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
⊢ weightSpace M 0 = ⊤
[PROOFSTEP]
rw [← LieSubmodule.coe_toSubmodule_eq_iff, LieSubmodule.top_coeSubmodule]
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
⊢ ↑(weightSpace M 0) = ⊤
[PROOFSTEP]
exact iInf_max_gen_zero_eigenspace_eq_top_of_nilpotent R L M
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
⊢ ↑(weightSpace M (χ ∘ ↑(LieSubalgebra.incl ⊤))) = ↑(weightSpace M χ)
[PROOFSTEP]
ext m
[GOAL]
case h
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
⊢ m ∈ ↑(weightSpace M (χ ∘ ↑(LieSubalgebra.incl ⊤))) ↔ m ∈ ↑(weightSpace M χ)
[PROOFSTEP]
simp only [weightSpace, LieSubmodule.coe_toSubmodule_mk, LieSubalgebra.coe_bracket_of_module, Function.comp_apply,
  mem_preWeightSpace]
[GOAL]
case h
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
⊢ (∀ (x : { x // x ∈ ⊤ }),
      ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0) ↔
    ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
[PROOFSTEP]
constructor
[GOAL]
case h.mp
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
⊢ (∀ (x : { x // x ∈ ⊤ }),
      ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0) →
    ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
[PROOFSTEP]
intro h x
[GOAL]
case h.mpr
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
⊢ (∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0) →
    ∀ (x : { x // x ∈ ⊤ }),
      ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0
[PROOFSTEP]
intro h x
[GOAL]
case h.mp
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
h :
  ∀ (x : { x // x ∈ ⊤ }), ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0
x : L
⊢ ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
[PROOFSTEP]
obtain ⟨k, hk⟩ := h ⟨x, Set.mem_univ x⟩
[GOAL]
case h.mp.intro
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
h :
  ∀ (x : { x // x ∈ ⊤ }), ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0
x : L
k : ℕ
hk :
  ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) { val := x, property := (_ : x ∈ Set.univ) } -
            χ (↑(LieSubalgebra.incl ⊤) { val := x, property := (_ : x ∈ Set.univ) }) • 1) ^
          k)
      m =
    0
⊢ ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
[PROOFSTEP]
use k
[GOAL]
case h
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
h :
  ∀ (x : { x // x ∈ ⊤ }), ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0
x : L
k : ℕ
hk :
  ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) { val := x, property := (_ : x ∈ Set.univ) } -
            χ (↑(LieSubalgebra.incl ⊤) { val := x, property := (_ : x ∈ Set.univ) }) • 1) ^
          k)
      m =
    0
⊢ ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
[PROOFSTEP]
exact hk
[GOAL]
case h.mpr
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
h : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
x : { x // x ∈ ⊤ }
⊢ ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0
[PROOFSTEP]
obtain ⟨k, hk⟩ := h x
[GOAL]
case h.mpr.intro
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
h : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
x : { x // x ∈ ⊤ }
k : ℕ
hk : ↑((↑(toEndomorphism R L M) ↑x - χ ↑x • 1) ^ k) m = 0
⊢ ∃ k, ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0
[PROOFSTEP]
use k
[GOAL]
case h
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : LieAlgebra.IsNilpotent R L
χ : L → R
m : M
h : ∀ (x : L), ∃ k, ↑((↑(toEndomorphism R L M) x - χ x • 1) ^ k) m = 0
x : { x // x ∈ ⊤ }
k : ℕ
hk : ↑((↑(toEndomorphism R L M) ↑x - χ ↑x • 1) ^ k) m = 0
⊢ ↑((↑(toEndomorphism R { x // x ∈ ⊤ } M) x - χ (↑(LieSubalgebra.incl ⊤) x) • 1) ^ k) m = 0
[PROOFSTEP]
exact hk
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
⊢ weightSpace M 0 = ⊤
[PROOFSTEP]
have h₀ : (0 : L → R) ∘ (⊤ : LieSubalgebra R L).incl = 0 := by ext; rfl
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
⊢ 0 ∘ ↑(LieSubalgebra.incl ⊤) = 0
[PROOFSTEP]
ext
[GOAL]
case h
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
x✝ : { x // x ∈ ⊤ }
⊢ (0 ∘ ↑(LieSubalgebra.incl ⊤)) x✝ = OfNat.ofNat 0 x✝
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
h₀ : 0 ∘ ↑(LieSubalgebra.incl ⊤) = 0
⊢ weightSpace M 0 = ⊤
[PROOFSTEP]
rw [← LieSubmodule.coe_toSubmodule_eq_iff, LieSubmodule.top_coeSubmodule, ← h₀, coe_weightSpace_of_top, ←
  iInf_max_gen_zero_eigenspace_eq_top_of_nilpotent R L M]
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
h₀ : 0 ∘ ↑(LieSubalgebra.incl ⊤) = 0
⊢ ↑(weightSpace M 0) = ⨅ (x : L), Module.End.maximalGeneralizedEigenspace (↑(toEndomorphism R L M) x) 0
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁷ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : LieRingModule L M
inst✝³ : LieModule R L M
inst✝² : Nontrivial M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
⊢ IsWeight ⊤ M 0
[PROOFSTEP]
rw [IsWeight, LieHom.coe_zero, zero_weightSpace_eq_top_of_nilpotent]
[GOAL]
R : Type u
L : Type v
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁷ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁶ : AddCommGroup M
inst✝⁵ : Module R M
inst✝⁴ : LieRingModule L M
inst✝³ : LieModule R L M
inst✝² : Nontrivial M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNilpotent R L M
⊢ ⊤ ≠ ⊥
[PROOFSTEP]
exact top_ne_bot
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNoetherian R M
x : L
⊢ _root_.IsNilpotent (↑(toEndomorphism R L { x // x ∈ ↑(weightSpace M 0) }) x)
[PROOFSTEP]
obtain ⟨k, hk⟩ := exists_preWeightSpace_zero_le_ker_of_isNoetherian R M x
[GOAL]
case intro
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNoetherian R M
x : L
k : ℕ
hk : preWeightSpace M 0 ≤ LinearMap.ker (↑(toEndomorphism R L M) x ^ k)
⊢ _root_.IsNilpotent (↑(toEndomorphism R L { x // x ∈ ↑(weightSpace M 0) }) x)
[PROOFSTEP]
use k
[GOAL]
case h
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNoetherian R M
x : L
k : ℕ
hk : preWeightSpace M 0 ≤ LinearMap.ker (↑(toEndomorphism R L M) x ^ k)
⊢ ↑(toEndomorphism R L { x // x ∈ ↑(weightSpace M 0) }) x ^ k = 0
[PROOFSTEP]
ext ⟨m, hm⟩
[GOAL]
case h.h.mk.a
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNoetherian R M
x : L
k : ℕ
hk : preWeightSpace M 0 ≤ LinearMap.ker (↑(toEndomorphism R L M) x ^ k)
m : M
hm : m ∈ ↑(weightSpace M 0)
⊢ ↑(↑(↑(toEndomorphism R L { x // x ∈ ↑(weightSpace M 0) }) x ^ k) { val := m, property := hm }) =
    ↑(↑0 { val := m, property := hm })
[PROOFSTEP]
rw [LinearMap.zero_apply, LieSubmodule.coe_zero, Submodule.coe_eq_zero, ←
  LieSubmodule.toEndomorphism_restrict_eq_toEndomorphism, LinearMap.pow_restrict, ← SetLike.coe_eq_coe,
  LinearMap.restrict_apply, Submodule.coe_mk, Submodule.coe_zero]
[GOAL]
case h.h.mk.a
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁶ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
inst✝¹ : LieAlgebra.IsNilpotent R L
inst✝ : IsNoetherian R M
x : L
k : ℕ
hk : preWeightSpace M 0 ≤ LinearMap.ker (↑(toEndomorphism R L M) x ^ k)
m : M
hm : m ∈ ↑(weightSpace M 0)
⊢ ↑(↑(toEndomorphism R L M) x ^ k) ↑{ val := m, property := hm } = 0
[PROOFSTEP]
exact hk hm
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
⊢ LieSubmodule.comap (LieSubalgebra.incl' H) (rootSpace H χ) = weightSpace { x // x ∈ H } χ
[PROOFSTEP]
ext x
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
⊢ x ∈ LieSubmodule.comap (LieSubalgebra.incl' H) (rootSpace H χ) ↔ x ∈ weightSpace { x // x ∈ H } χ
[PROOFSTEP]
let f : H → Module.End R L := fun y => toEndomorphism R H L y - χ y • ↑1
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
⊢ x ∈ LieSubmodule.comap (LieSubalgebra.incl' H) (rootSpace H χ) ↔ x ∈ weightSpace { x // x ∈ H } χ
[PROOFSTEP]
let g : H → Module.End R H := fun y => toEndomorphism R H H y - χ y • ↑1
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
⊢ x ∈ LieSubmodule.comap (LieSubalgebra.incl' H) (rootSpace H χ) ↔ x ∈ weightSpace { x // x ∈ H } χ
[PROOFSTEP]
suffices
  (∀ y : H, ∃ k : ℕ, (f y ^ k).comp (H.incl : H →ₗ[R] L) x = 0) ↔
    ∀ y : H, ∃ k : ℕ, (H.incl : H →ₗ[R] L).comp (g y ^ k) x = 0
  by
  simp only [LieHom.coe_toLinearMap, LieSubalgebra.coe_incl, Function.comp_apply, LinearMap.coe_comp,
    Submodule.coe_eq_zero] at this
  simp only [mem_weightSpace, mem_preWeightSpace, LieSubalgebra.coe_incl', LieSubmodule.mem_comap, this]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
this :
  (∀ (y : { x // x ∈ H }), ∃ k, ↑(LinearMap.comp (f y ^ k) ↑(LieSubalgebra.incl H)) x = 0) ↔
    ∀ (y : { x // x ∈ H }), ∃ k, ↑(LinearMap.comp (↑(LieSubalgebra.incl H)) (g y ^ k)) x = 0
⊢ x ∈ LieSubmodule.comap (LieSubalgebra.incl' H) (rootSpace H χ) ↔ x ∈ weightSpace { x // x ∈ H } χ
[PROOFSTEP]
simp only [LieHom.coe_toLinearMap, LieSubalgebra.coe_incl, Function.comp_apply, LinearMap.coe_comp,
  Submodule.coe_eq_zero] at this
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
this :
  (∀ (y : { x // x ∈ H }), ∃ k, ↑((↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1) ^ k) ↑x = 0) ↔
    ∀ (y : { x // x ∈ H }), ∃ k, ↑((↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1) ^ k) x = 0
⊢ x ∈ LieSubmodule.comap (LieSubalgebra.incl' H) (rootSpace H χ) ↔ x ∈ weightSpace { x // x ∈ H } χ
[PROOFSTEP]
simp only [mem_weightSpace, mem_preWeightSpace, LieSubalgebra.coe_incl', LieSubmodule.mem_comap, this]
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
⊢ (∀ (y : { x // x ∈ H }), ∃ k, ↑(LinearMap.comp (f y ^ k) ↑(LieSubalgebra.incl H)) x = 0) ↔
    ∀ (y : { x // x ∈ H }), ∃ k, ↑(LinearMap.comp (↑(LieSubalgebra.incl H)) (g y ^ k)) x = 0
[PROOFSTEP]
have hfg : ∀ y : H, (f y).comp (H.incl : H →ₗ[R] L) = (H.incl : H →ₗ[R] L).comp (g y) :=
  by
  rintro ⟨y, hy⟩; ext ⟨z, _⟩
  simp only [Submodule.coe_sub, toEndomorphism_apply_apply, LieHom.coe_toLinearMap, LinearMap.one_apply,
    LieSubalgebra.coe_incl, LieSubalgebra.coe_bracket_of_module, LieSubalgebra.coe_bracket, LinearMap.smul_apply,
    Function.comp_apply, Submodule.coe_smul_of_tower, LinearMap.coe_comp, LinearMap.sub_apply]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
⊢ ∀ (y : { x // x ∈ H }), LinearMap.comp (f y) ↑(LieSubalgebra.incl H) = LinearMap.comp (↑(LieSubalgebra.incl H)) (g y)
[PROOFSTEP]
rintro ⟨y, hy⟩
[GOAL]
case mk
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
y : L
hy : y ∈ H
⊢ LinearMap.comp (f { val := y, property := hy }) ↑(LieSubalgebra.incl H) =
    LinearMap.comp (↑(LieSubalgebra.incl H)) (g { val := y, property := hy })
[PROOFSTEP]
ext ⟨z, _⟩
[GOAL]
case mk.h.mk
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
y : L
hy : y ∈ H
z : L
property✝ : z ∈ H
⊢ ↑(LinearMap.comp (f { val := y, property := hy }) ↑(LieSubalgebra.incl H)) { val := z, property := property✝ } =
    ↑(LinearMap.comp (↑(LieSubalgebra.incl H)) (g { val := y, property := hy })) { val := z, property := property✝ }
[PROOFSTEP]
simp only [Submodule.coe_sub, toEndomorphism_apply_apply, LieHom.coe_toLinearMap, LinearMap.one_apply,
  LieSubalgebra.coe_incl, LieSubalgebra.coe_bracket_of_module, LieSubalgebra.coe_bracket, LinearMap.smul_apply,
  Function.comp_apply, Submodule.coe_smul_of_tower, LinearMap.coe_comp, LinearMap.sub_apply]
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
x : { x // x ∈ H }
f : { x // x ∈ H } → Module.End R L := fun y => ↑(toEndomorphism R { x // x ∈ H } L) y - χ y • 1
g : { x // x ∈ H } → Module.End R { x // x ∈ H } :=
  fun y => ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y - χ y • 1
hfg :
  ∀ (y : { x // x ∈ H }), LinearMap.comp (f y) ↑(LieSubalgebra.incl H) = LinearMap.comp (↑(LieSubalgebra.incl H)) (g y)
⊢ (∀ (y : { x // x ∈ H }), ∃ k, ↑(LinearMap.comp (f y ^ k) ↑(LieSubalgebra.incl H)) x = 0) ↔
    ∀ (y : { x // x ∈ H }), ∃ k, ↑(LinearMap.comp (↑(LieSubalgebra.incl H)) (g y ^ k)) x = 0
[PROOFSTEP]
simp_rw [LinearMap.commute_pow_left_of_commute (hfg _)]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : { x // x ∈ H } → R
x : L
m : M
hx : x ∈ rootSpace H χ₁
hm : m ∈ weightSpace M χ₂
⊢ ⁅x, m⁆ ∈ weightSpace M (χ₁ + χ₂)
[PROOFSTEP]
apply LieModule.weight_vector_multiplication H L M M ((toModuleHom R L M).restrictLie H) χ₁ χ₂
[GOAL]
case a
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : { x // x ∈ H } → R
x : L
m : M
hx : x ∈ rootSpace H χ₁
hm : m ∈ weightSpace M χ₂
⊢ ⁅x, m⁆ ∈
    LinearMap.range
      (LinearMap.comp (↑(LieModuleHom.restrictLie (toModuleHom R L M) H))
        (TensorProduct.mapIncl (preWeightSpace L χ₁) (preWeightSpace M χ₂)))
[PROOFSTEP]
simp only [LieModuleHom.coe_toLinearMap, Function.comp_apply, LinearMap.coe_comp, TensorProduct.mapIncl,
  LinearMap.mem_range]
[GOAL]
case a
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : { x // x ∈ H } → R
x : L
m : M
hx : x ∈ rootSpace H χ₁
hm : m ∈ weightSpace M χ₂
⊢ ∃ y,
    ↑(LieModuleHom.restrictLie (toModuleHom R L M) H)
        (↑(TensorProduct.map (Submodule.subtype (preWeightSpace L χ₁)) (Submodule.subtype (preWeightSpace M χ₂))) y) =
      ⁅x, m⁆
[PROOFSTEP]
use⟨x, hx⟩ ⊗ₜ ⟨m, hm⟩
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ : { x // x ∈ H } → R
x : L
m : M
hx : x ∈ rootSpace H χ₁
hm : m ∈ weightSpace M χ₂
⊢ ↑(LieModuleHom.restrictLie (toModuleHom R L M) H)
      (↑(TensorProduct.map (Submodule.subtype (preWeightSpace L χ₁)) (Submodule.subtype (preWeightSpace M χ₂)))
        ({ val := x, property := hx } ⊗ₜ[R] { val := m, property := hm })) =
    ⁅x, m⁆
[PROOFSTEP]
simp only [Submodule.subtype_apply, toModuleHom_apply, Submodule.coe_mk, LieModuleHom.coe_restrictLie,
  TensorProduct.map_tmul]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
m n : { x // x ∈ ↑(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
[PROOFSTEP]
simp only [LieSubmodule.coe_add, lie_add]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
m n : { x // x ∈ ↑(weightSpace M χ₂) }
⊢ { val := ⁅↑x, ↑m⁆ + ⁅↑x, ↑n⁆, property := (_ : (fun x => x ∈ ↑(weightSpace M χ₃)) (⁅↑x, ↑m⁆ + ⁅↑x, ↑n⁆)) } =
    { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) } +
      { val := ⁅↑x, ↑n⁆, property := (_ : ⁅↑x, ↑n⁆ ∈ ↑(weightSpace M χ₃)) }
[PROOFSTEP]
rfl
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
t : R
m : { x // x ∈ ↑(weightSpace M χ₂) }
⊢ AddHom.toFun
      { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
        map_add' :=
          (_ :
            ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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
[PROOFSTEP]
dsimp only
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
t : R
m : { x // x ∈ ↑(weightSpace M χ₂) }
⊢ { val := ⁅↑x, ↑(t • m)⁆, property := (_ : ⁅↑x, ↑(t • m)⁆ ∈ ↑(weightSpace M χ₃)) } =
    ↑(RingHom.id R) t • { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) }
[PROOFSTEP]
conv_lhs =>
  congr
  rw [LieSubmodule.coe_smul, lie_smul]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
t : R
m : { x // x ∈ ↑(weightSpace M χ₂) }
| { val := ⁅↑x, ↑(t • m)⁆, property := (_ : ⁅↑x, ↑(t • m)⁆ ∈ ↑(weightSpace M χ₃)) }
[PROOFSTEP]
  congr
  rw [LieSubmodule.coe_smul, lie_smul]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
t : R
m : { x // x ∈ ↑(weightSpace M χ₂) }
| { val := ⁅↑x, ↑(t • m)⁆, property := (_ : ⁅↑x, ↑(t • m)⁆ ∈ ↑(weightSpace M χ₃)) }
[PROOFSTEP]
  congr
  rw [LieSubmodule.coe_smul, lie_smul]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
t : R
m : { x // x ∈ ↑(weightSpace M χ₂) }
| { val := ⁅↑x, ↑(t • m)⁆, property := (_ : ⁅↑x, ↑(t • m)⁆ ∈ ↑(weightSpace M χ₃)) }
[PROOFSTEP]
congr
[GOAL]
case val
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ ↑(rootSpace H χ₁) }
t : R
m : { x // x ∈ ↑(weightSpace M χ₂) }
| ⁅↑x, ↑(t • m)⁆
[PROOFSTEP]
rw [LieSubmodule.coe_smul, lie_smul]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x y : { x // x ∈ ↑(rootSpace H χ₁) }
⊢ (fun x =>
        {
          toAddHom :=
            { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
              map_add' :=
                (_ :
                  ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                AddHom.toFun
                    { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                      map_add' :=
                        (_ :
                          ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                  AddHom.toFun
                      { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                        map_add' :=
                          (_ :
                            ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                  AddHom.toFun
                      { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                        map_add' :=
                          (_ :
                            ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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
[PROOFSTEP]
ext m
[GOAL]
case h.a
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x y : { x // x ∈ ↑(rootSpace H χ₁) }
m : { x // x ∈ ↑(weightSpace M χ₂) }
⊢ ↑(↑((fun x =>
              {
                toAddHom :=
                  { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                    map_add' :=
                      (_ :
                        ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                      AddHom.toFun
                          { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                            map_add' :=
                              (_ :
                                ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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))
        m) =
    ↑(↑((fun x =>
                {
                  toAddHom :=
                    { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                      map_add' :=
                        (_ :
                          ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                        AddHom.toFun
                            { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                              map_add' :=
                                (_ :
                                  ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                        AddHom.toFun
                            { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                              map_add' :=
                                (_ :
                                  ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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)
        m)
[PROOFSTEP]
simp only [AddSubmonoid.coe_add, Submodule.coe_toAddSubmonoid, add_lie, LinearMap.coe_mk, AddHom.coe_mk,
  LinearMap.add_apply, AddSubmonoid.mk_add_mk]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
t : R
x : { x // x ∈ ↑(rootSpace H χ₁) }
⊢ AddHom.toFun
      {
        toFun := fun x =>
          {
            toAddHom :=
              { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                map_add' :=
                  (_ :
                    ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                  AddHom.toFun
                      { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                        map_add' :=
                          (_ :
                            ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(rootSpace H χ₁) }),
              (fun x =>
                    {
                      toAddHom :=
                        { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                          map_add' :=
                            (_ :
                              ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                            AddHom.toFun
                                {
                                  toFun := fun m =>
                                    { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                                  map_add' :=
                                    (_ :
                                      ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                              AddHom.toFun
                                  {
                                    toFun := fun m =>
                                      { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                                    map_add' :=
                                      (_ :
                                        ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                              AddHom.toFun
                                  {
                                    toFun := fun m =>
                                      { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                                    map_add' :=
                                      (_ :
                                        ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                    AddHom.toFun
                        { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                          map_add' :=
                            (_ :
                              ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(rootSpace H χ₁) }),
                (fun x =>
                      {
                        toAddHom :=
                          { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                            map_add' :=
                              (_ :
                                ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                              AddHom.toFun
                                  {
                                    toFun := fun m =>
                                      { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                                    map_add' :=
                                      (_ :
                                        ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                                AddHom.toFun
                                    {
                                      toFun := fun m =>
                                        { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                                      map_add' :=
                                        (_ :
                                          ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                                AddHom.toFun
                                    {
                                      toFun := fun m =>
                                        { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                                      map_add' :=
                                        (_ :
                                          ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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
[PROOFSTEP]
simp only [RingHom.id_apply]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
t : R
x : { x // x ∈ ↑(rootSpace H χ₁) }
⊢ {
      toAddHom :=
        { toFun := fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
          map_add' :=
            (_ :
              ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
            AddHom.toFun
                { toFun := fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                  map_add' :=
                    (_ :
                      ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
              AddHom.toFun
                  { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                    map_add' :=
                      (_ :
                        ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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) }
[PROOFSTEP]
ext m
[GOAL]
case h.a
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
t : R
x : { x // x ∈ ↑(rootSpace H χ₁) }
m : { x // x ∈ ↑(weightSpace M χ₂) }
⊢ ↑(↑{
            toAddHom :=
              { toFun := fun m => { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                map_add' :=
                  (_ :
                    ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                  AddHom.toFun
                      {
                        toFun := fun m =>
                          { val := ⁅↑(t • x), ↑m⁆, property := (_ : ⁅↑(t • x), ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                        map_add' :=
                          (_ :
                            ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(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 : { x // x ∈ ↑(weightSpace M χ₂) }),
                    AddHom.toFun
                        { toFun := fun m => { val := ⁅↑x, ↑m⁆, property := (_ : ⁅↑x, ↑m⁆ ∈ ↑(weightSpace M χ₃)) },
                          map_add' :=
                            (_ :
                              ∀ (m n : { x // x ∈ ↑(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 : { x // x ∈ ↑(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)
[PROOFSTEP]
simp only [SetLike.val_smul, smul_lie, LinearMap.coe_mk, AddHom.coe_mk, LinearMap.smul_apply, SetLike.mk_smul_mk]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ H }
y : { x // x ∈ ↑(rootSpace H χ₁) }
⊢ AddHom.toFun (rootSpaceWeightSpaceProductAux R L H M hχ).toAddHom ⁅x, y⁆ =
    ⁅x, AddHom.toFun (rootSpaceWeightSpaceProductAux R L H M hχ).toAddHom y⁆
[PROOFSTEP]
ext m
[GOAL]
case h.a
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ H }
y : { x // x ∈ ↑(rootSpace H χ₁) }
m : { x // x ∈ ↑(weightSpace M χ₂) }
⊢ ↑(↑(AddHom.toFun (rootSpaceWeightSpaceProductAux R L H M hχ).toAddHom ⁅x, y⁆) m) =
    ↑(↑⁅x, AddHom.toFun (rootSpaceWeightSpaceProductAux R L H M hχ).toAddHom y⁆ m)
[PROOFSTEP]
simp only [rootSpaceWeightSpaceProductAux, LieSubmodule.coe_bracket, LieSubalgebra.coe_bracket_of_module, lie_lie,
  LinearMap.coe_mk, AddHom.coe_mk, Subtype.coe_mk, LieHom.lie_apply, LieSubmodule.coe_sub]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ rootSpace H χ₁ }
m : { x // x ∈ weightSpace M χ₂ }
⊢ ↑(↑(rootSpaceWeightSpaceProduct R L H M χ₁ χ₂ χ₃ hχ) (x ⊗ₜ[R] m)) = ⁅↑x, ↑m⁆
[PROOFSTEP]
simp only [rootSpaceWeightSpaceProduct, rootSpaceWeightSpaceProductAux, coe_liftLie_eq_lift_coe, AddHom.toFun_eq_coe,
  LinearMap.coe_toAddHom, lift_apply, LinearMap.coe_mk, AddHom.coe_mk, Submodule.coe_mk]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ₁ χ₂ χ₃ : { x // x ∈ H } → R
hχ : χ₁ + χ₂ = χ₃
x : { x // x ∈ rootSpace H χ₁ }
y : { x // x ∈ rootSpace H χ₂ }
⊢ ↑(↑(rootSpaceProduct R L H χ₁ χ₂ χ₃ hχ) (x ⊗ₜ[R] y)) = ⁅↑x, ↑y⁆
[PROOFSTEP]
simp only [rootSpaceProduct_def, coe_rootSpaceWeightSpaceProduct_tmul]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
src✝ : Submodule R L := ↑(rootSpace H 0)
x y : L
hx :
  x ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hy :
  y ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ⁅x, y⁆ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
let xy : rootSpace H 0 ⊗[R] rootSpace H 0 := ⟨x, hx⟩ ⊗ₜ ⟨y, hy⟩
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
src✝ : Submodule R L := ↑(rootSpace H 0)
x y : L
hx :
  x ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hy :
  y ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
xy : { x // x ∈ ↑(rootSpace H 0) } ⊗[R] { x // x ∈ ↑(rootSpace H 0) } :=
  { val := x, property := hx } ⊗ₜ[R] { val := y, property := hy }
⊢ ⁅x, y⁆ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
suffices (rootSpaceProduct R L H 0 0 0 (add_zero 0) xy : L) ∈ rootSpace H 0 by
  rwa [rootSpaceProduct_tmul, Subtype.coe_mk, Subtype.coe_mk] at this
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
src✝ : Submodule R L := ↑(rootSpace H 0)
x y : L
hx :
  x ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hy :
  y ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
xy : { x // x ∈ ↑(rootSpace H 0) } ⊗[R] { x // x ∈ ↑(rootSpace H 0) } :=
  { val := x, property := hx } ⊗ₜ[R] { val := y, property := hy }
this : ↑(↑(rootSpaceProduct R L H 0 0 0 (_ : 0 + 0 = 0)) xy) ∈ rootSpace H 0
⊢ ⁅x, y⁆ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
rwa [rootSpaceProduct_tmul, Subtype.coe_mk, Subtype.coe_mk] at this
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
src✝ : Submodule R L := ↑(rootSpace H 0)
x y : L
hx :
  x ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hy :
  y ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
xy : { x // x ∈ ↑(rootSpace H 0) } ⊗[R] { x // x ∈ ↑(rootSpace H 0) } :=
  { val := x, property := hx } ⊗ₜ[R] { val := y, property := hy }
⊢ ↑(↑(rootSpaceProduct R L H 0 0 0 (_ : 0 + 0 = 0)) xy) ∈ rootSpace H 0
[PROOFSTEP]
exact (rootSpaceProduct R L H 0 0 0 (add_zero 0) xy).property
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ x ∈ zeroRootSubalgebra R L H ↔ ∀ (y : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
rw [zeroRootSubalgebra]
  -- Porting note: added the following `change` otherwise the `simp` fails
    -- See https://github.com/leanprover-community/mathlib4/issues/5026
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ (x ∈
      let src := ↑(rootSpace H 0);
      {
        toSubmodule :=
          { toAddSubmonoid := src.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : L},
                  x ∈ (↑(rootSpace H 0)).toAddSubmonoid.toAddSubsemigroup.carrier →
                    c • x ∈ (↑(rootSpace H 0)).toAddSubmonoid.toAddSubsemigroup.carrier) },
        lie_mem' :=
          (_ :
            ∀ {x y : L}
              {hx :
                x ∈
                  { toAddSubmonoid := (↑(rootSpace H 0)).toAddSubmonoid,
                          smul_mem' :=
                            (_ :
                              ∀ (c : R) {x : L},
                                x ∈ (↑(rootSpace H 0)).toAddSubmonoid.toAddSubsemigroup.carrier →
                                  c • x ∈
                                    (↑(rootSpace H
                                              0)).toAddSubmonoid.toAddSubsemigroup.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier}
              {hy :
                y ∈
                  { toAddSubmonoid := (↑(rootSpace H 0)).toAddSubmonoid,
                          smul_mem' :=
                            (_ :
                              ∀ (c : R) {x : L},
                                x ∈ (↑(rootSpace H 0)).toAddSubmonoid.toAddSubsemigroup.carrier →
                                  c • x ∈
                                    (↑(rootSpace H
                                              0)).toAddSubmonoid.toAddSubsemigroup.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier},
              ⁅x, y⁆ ∈ rootSpace H 0) }) ↔
    ∀ (y : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
change x ∈ rootSpace H 0 ↔ _
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
⊢ x ∈ rootSpace H 0 ↔ ∀ (y : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
simp only [mem_weightSpace, mem_preWeightSpace, Pi.zero_apply, zero_smul, sub_zero]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ LieSubalgebra.toLieSubmodule H ≤ rootSpace H 0
[PROOFSTEP]
intro x hx
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ LieSubalgebra.toLieSubmodule H
⊢ x ∈ rootSpace H 0
[PROOFSTEP]
simp only [LieSubalgebra.mem_toLieSubmodule] at hx
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
⊢ x ∈ rootSpace H 0
[PROOFSTEP]
simp only [mem_weightSpace, mem_preWeightSpace, Pi.zero_apply, sub_zero, zero_smul]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
⊢ ∀ (x_1 : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) x_1 ^ k) x = 0
[PROOFSTEP]
intro y
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
⊢ ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
obtain ⟨k, hk⟩ := (inferInstance : IsNilpotent R H)
[GOAL]
case mk.intro
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
⊢ ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
use k
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
⊢ ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
let f : Module.End R H := toEndomorphism R H H y
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
⊢ ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
let g : Module.End R L := toEndomorphism R H L y
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
⊢ ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
have hfg : g.comp (H : Submodule R L).subtype = (H : Submodule R L).subtype.comp f :=
  by
  ext z
  simp only [toEndomorphism_apply_apply, Submodule.subtype_apply, LieSubalgebra.coe_bracket_of_module,
    LieSubalgebra.coe_bracket, Function.comp_apply, LinearMap.coe_comp]
  rfl
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
⊢ LinearMap.comp g (Submodule.subtype H.toSubmodule) = LinearMap.comp (Submodule.subtype H.toSubmodule) f
[PROOFSTEP]
ext z
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
z : { x // x ∈ H.toSubmodule }
⊢ ↑(LinearMap.comp g (Submodule.subtype H.toSubmodule)) z = ↑(LinearMap.comp (Submodule.subtype H.toSubmodule) f) z
[PROOFSTEP]
simp only [toEndomorphism_apply_apply, Submodule.subtype_apply, LieSubalgebra.coe_bracket_of_module,
  LieSubalgebra.coe_bracket, Function.comp_apply, LinearMap.coe_comp]
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
z : { x // x ∈ H.toSubmodule }
⊢ ⁅↑y, ↑z⁆ = ↑(↑(↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y) z)
[PROOFSTEP]
rfl
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
hfg : LinearMap.comp g (Submodule.subtype H.toSubmodule) = LinearMap.comp (Submodule.subtype H.toSubmodule) f
⊢ ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
change (g ^ k).comp (H : Submodule R L).subtype ⟨x, hx⟩ = 0
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
hfg : LinearMap.comp g (Submodule.subtype H.toSubmodule) = LinearMap.comp (Submodule.subtype H.toSubmodule) f
⊢ ↑(LinearMap.comp (g ^ k) (Submodule.subtype H.toSubmodule)) { val := x, property := hx } = 0
[PROOFSTEP]
rw [LinearMap.commute_pow_left_of_commute hfg k]
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
hfg : LinearMap.comp g (Submodule.subtype H.toSubmodule) = LinearMap.comp (Submodule.subtype H.toSubmodule) f
⊢ ↑(LinearMap.comp (Submodule.subtype H.toSubmodule) (f ^ k)) { val := x, property := hx } = 0
[PROOFSTEP]
have h := iterate_toEndomorphism_mem_lowerCentralSeries R H H y ⟨x, hx⟩ k
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
hfg : LinearMap.comp g (Submodule.subtype H.toSubmodule) = LinearMap.comp (Submodule.subtype H.toSubmodule) f
h :
  (↑(↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y))^[k] { val := x, property := hx } ∈
    lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k
⊢ ↑(LinearMap.comp (Submodule.subtype H.toSubmodule) (f ^ k)) { val := x, property := hx } = 0
[PROOFSTEP]
rw [hk, LieSubmodule.mem_bot] at h
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
hfg : LinearMap.comp g (Submodule.subtype H.toSubmodule) = LinearMap.comp (Submodule.subtype H.toSubmodule) f
h : (↑(↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y))^[k] { val := x, property := hx } = 0
⊢ ↑(LinearMap.comp (Submodule.subtype H.toSubmodule) (f ^ k)) { val := x, property := hx } = 0
[PROOFSTEP]
simp only [Submodule.subtype_apply, Function.comp_apply, LinearMap.pow_apply, LinearMap.coe_comp, Submodule.coe_eq_zero]
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ H
y : { x // x ∈ H }
k : ℕ
hk : lowerCentralSeries R { x // x ∈ H } { x // x ∈ H } k = ⊥
f : Module.End R { x // x ∈ H } := ↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y
g : Module.End R L := ↑(toEndomorphism R { x // x ∈ H } L) y
hfg : LinearMap.comp g (Submodule.subtype H.toSubmodule) = LinearMap.comp (Submodule.subtype H.toSubmodule) f
h : (↑(↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y))^[k] { val := x, property := hx } = 0
⊢ (↑(↑(toEndomorphism R { x // x ∈ H } { x // x ∈ H }) y))^[k] { val := x, property := hx } = 0
[PROOFSTEP]
exact h
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ H ≤ zeroRootSubalgebra R L H
[PROOFSTEP]
rw [← LieSubalgebra.coe_submodule_le_coe_submodule, ← H.coe_toLieSubmodule, coe_zeroRootSubalgebra,
  LieSubmodule.coeSubmodule_le_coeSubmodule]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ LieSubalgebra.toLieSubmodule H ≤ rootSpace H 0
[PROOFSTEP]
exact toLieSubmodule_le_rootSpace_zero R L H
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ LieSubalgebra.normalizer (zeroRootSubalgebra R L H) = zeroRootSubalgebra R L H
[PROOFSTEP]
refine' le_antisymm _ (LieSubalgebra.le_normalizer _)
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ LieSubalgebra.normalizer (zeroRootSubalgebra R L H) ≤ zeroRootSubalgebra R L H
[PROOFSTEP]
intro x hx
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : x ∈ LieSubalgebra.normalizer (zeroRootSubalgebra R L H)
⊢ x ∈ zeroRootSubalgebra R L H
[PROOFSTEP]
rw [LieSubalgebra.mem_normalizer_iff] at hx
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : ∀ (y : L), y ∈ zeroRootSubalgebra R L H → ⁅x, y⁆ ∈ zeroRootSubalgebra R L H
⊢ x ∈ zeroRootSubalgebra R L H
[PROOFSTEP]
rw [mem_zeroRootSubalgebra]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : ∀ (y : L), y ∈ zeroRootSubalgebra R L H → ⁅x, y⁆ ∈ zeroRootSubalgebra R L H
⊢ ∀ (y : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y ^ k) x = 0
[PROOFSTEP]
rintro ⟨y, hy⟩
[GOAL]
case mk
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x : L
hx : ∀ (y : L), y ∈ zeroRootSubalgebra R L H → ⁅x, y⁆ ∈ zeroRootSubalgebra R L H
y : L
hy : y ∈ H
⊢ ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) x = 0
[PROOFSTEP]
specialize hx y (le_zeroRootSubalgebra R L H hy)
[GOAL]
case mk
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
hy : y ∈ H
hx : ⁅x, y⁆ ∈ zeroRootSubalgebra R L H
⊢ ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) x = 0
[PROOFSTEP]
rw [mem_zeroRootSubalgebra] at hx
[GOAL]
case mk
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
hy : y ∈ H
hx : ∀ (y_1 : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y_1 ^ k) ⁅x, y⁆ = 0
⊢ ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) x = 0
[PROOFSTEP]
obtain ⟨k, hk⟩ := hx ⟨y, hy⟩
[GOAL]
case mk.intro
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
hy : y ∈ H
hx : ∀ (y_1 : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y_1 ^ k) ⁅x, y⁆ = 0
k : ℕ
hk : ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) ⁅x, y⁆ = 0
⊢ ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) x = 0
[PROOFSTEP]
rw [← lie_skew, LinearMap.map_neg, neg_eq_zero] at hk
[GOAL]
case mk.intro
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
hy : y ∈ H
hx : ∀ (y_1 : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y_1 ^ k) ⁅x, y⁆ = 0
k : ℕ
hk : ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) ⁅y, x⁆ = 0
⊢ ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) x = 0
[PROOFSTEP]
use k + 1
[GOAL]
case h
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
x y : L
hy : y ∈ H
hx : ∀ (y_1 : { x // x ∈ H }), ∃ k, ↑(↑(toEndomorphism R { x // x ∈ H } L) y_1 ^ k) ⁅x, y⁆ = 0
k : ℕ
hk : ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ k) ⁅y, x⁆ = 0
⊢ ↑(↑(toEndomorphism R { x // x ∈ H } L) { val := y, property := hy } ^ (k + 1)) x = 0
[PROOFSTEP]
rw [LinearMap.iterate_succ, LinearMap.coe_comp, Function.comp_apply, toEndomorphism_apply_apply,
  LieSubalgebra.coe_bracket_of_module, Submodule.coe_mk, hk]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h : zeroRootSubalgebra R L H = H
⊢ LieSubalgebra.normalizer H = H
[PROOFSTEP]
rw [← h]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
h : zeroRootSubalgebra R L H = H
⊢ LieSubalgebra.normalizer (zeroRootSubalgebra R L H) = zeroRootSubalgebra R L H
[PROOFSTEP]
exact zeroRootSubalgebra_normalizer_eq_self R L H
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝⁶ : IsNilpotent R { x // x ∈ H✝ }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
H : LieSubalgebra R L
inst✝¹ : LieSubalgebra.IsCartanSubalgebra H
inst✝ : IsNoetherian R L
⊢ zeroRootSubalgebra R L H = H
[PROOFSTEP]
refine' le_antisymm _ (le_zeroRootSubalgebra R L H)
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝⁶ : IsNilpotent R { x // x ∈ H✝ }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
H : LieSubalgebra R L
inst✝¹ : LieSubalgebra.IsCartanSubalgebra H
inst✝ : IsNoetherian R L
⊢ zeroRootSubalgebra R L H ≤ H
[PROOFSTEP]
suffices rootSpace H 0 ≤ H.toLieSubmodule by exact fun x hx => this hx
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝⁶ : IsNilpotent R { x // x ∈ H✝ }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
H : LieSubalgebra R L
inst✝¹ : LieSubalgebra.IsCartanSubalgebra H
inst✝ : IsNoetherian R L
this : rootSpace H 0 ≤ LieSubalgebra.toLieSubmodule H
⊢ zeroRootSubalgebra R L H ≤ H
[PROOFSTEP]
exact fun x hx => this hx
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝⁶ : IsNilpotent R { x // x ∈ H✝ }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
H : LieSubalgebra R L
inst✝¹ : LieSubalgebra.IsCartanSubalgebra H
inst✝ : IsNoetherian R L
⊢ rootSpace H 0 ≤ LieSubalgebra.toLieSubmodule H
[PROOFSTEP]
obtain ⟨k, hk⟩ := (rootSpace H 0).isNilpotent_iff_exists_self_le_ucs.mp (by infer_instance)
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝⁶ : IsNilpotent R { x // x ∈ H✝ }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
H : LieSubalgebra R L
inst✝¹ : LieSubalgebra.IsCartanSubalgebra H
inst✝ : IsNoetherian R L
⊢ LieModule.IsNilpotent R { x // x ∈ H } { x // x ∈ ↑(rootSpace H 0) }
[PROOFSTEP]
infer_instance
[GOAL]
case intro
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝⁶ : IsNilpotent R { x // x ∈ H✝ }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
H : LieSubalgebra R L
inst✝¹ : LieSubalgebra.IsCartanSubalgebra H
inst✝ : IsNoetherian R L
k : ℕ
hk : rootSpace H 0 ≤ LieSubmodule.ucs k ⊥
⊢ rootSpace H 0 ≤ LieSubalgebra.toLieSubmodule H
[PROOFSTEP]
exact hk.trans (LieSubmodule.ucs_le_of_normalizer_eq_self (by simp) k)
[GOAL]
R : Type u
L : Type v
inst✝⁹ : CommRing R
inst✝⁸ : LieRing L
inst✝⁷ : LieAlgebra R L
H✝ : LieSubalgebra R L
inst✝⁶ : IsNilpotent R { x // x ∈ H✝ }
M : Type w
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
inst✝³ : LieRingModule L M
inst✝² : LieModule R L M
H : LieSubalgebra R L
inst✝¹ : LieSubalgebra.IsCartanSubalgebra H
inst✝ : IsNoetherian R L
k : ℕ
hk : rootSpace H 0 ≤ LieSubmodule.ucs k ⊥
⊢ LieSubmodule.normalizer (LieSubalgebra.toLieSubmodule H) = LieSubalgebra.toLieSubmodule H
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R L
⊢ LieSubalgebra.IsCartanSubalgebra H → zeroRootSubalgebra R L H = H
[PROOFSTEP]
intros
[GOAL]
R : Type u
L : Type v
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁵ : IsNilpotent R { x // x ∈ H }
M : Type w
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R L
a✝ : LieSubalgebra.IsCartanSubalgebra H
⊢ zeroRootSubalgebra R L H = H
[PROOFSTEP]
simp
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
src✝ : Submodule R M := ↑(weightSpace M χ)
x : { x // x ∈ zeroRootSubalgebra R L H }
m : M
hm :
  m ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ⁅x, m⁆ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
have hx : (x : L) ∈ rootSpace H 0 := by rw [← LieSubmodule.mem_coeSubmodule, ← coe_zeroRootSubalgebra]; exact x.prop
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
src✝ : Submodule R M := ↑(weightSpace M χ)
x : { x // x ∈ zeroRootSubalgebra R L H }
m : M
hm :
  m ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ↑x ∈ rootSpace H 0
[PROOFSTEP]
rw [← LieSubmodule.mem_coeSubmodule, ← coe_zeroRootSubalgebra]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
src✝ : Submodule R M := ↑(weightSpace M χ)
x : { x // x ∈ zeroRootSubalgebra R L H }
m : M
hm :
  m ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
⊢ ↑x ∈ (zeroRootSubalgebra R L H).toSubmodule
[PROOFSTEP]
exact x.prop
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
src✝ : Submodule R M := ↑(weightSpace M χ)
x : { x // x ∈ zeroRootSubalgebra R L H }
m : M
hm :
  m ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hx : ↑x ∈ rootSpace H 0
⊢ ⁅x, m⁆ ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
dsimp only
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
src✝ : Submodule R M := ↑(weightSpace M χ)
x : { x // x ∈ zeroRootSubalgebra R L H }
m : M
hm :
  m ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hx : ↑x ∈ rootSpace H 0
⊢ ⁅x, m⁆ ∈ (↑(weightSpace M χ)).toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
rw [← zero_add χ]
[GOAL]
R : Type u
L : Type v
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
H : LieSubalgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R { x // x ∈ H }
M : Type w
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : { x // x ∈ H } → R
src✝ : Submodule R M := ↑(weightSpace M χ)
x : { x // x ∈ zeroRootSubalgebra R L H }
m : M
hm :
  m ∈
    { toAddSubmonoid := src✝.toAddSubmonoid,
            smul_mem' :=
              (_ :
                ∀ (c : R) {x : M}, x ∈ src✝.carrier → c • x ∈ src✝.carrier) }.toAddSubmonoid.toAddSubsemigroup.carrier
hx : ↑x ∈ rootSpace H 0
⊢ ⁅x, m⁆ ∈ (↑(weightSpace M (0 + χ))).toAddSubmonoid.toAddSubsemigroup.carrier
[PROOFSTEP]
exact lie_mem_weightSpace_of_mem_weightSpace hx hm