l3lab/ntp-mathlib huggingface dataset:
theorem coe_weightSpace_of_top (χ : L → R) :
    (weightSpace M (χ ∘ (⊤ : LieSubalgebra R L).incl) : Submodule R M) = weightSpace M χ := by
  ext m
  simp only [mem_weightSpace, LieSubmodule.mem_coeSubmodule, Subtype.forall]
  apply forall_congr'
  

Proof state:
case h.h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
χ : L → R
m : M
⊢ ∀ (a : L),
    (∀ (b : a ∈ ⊤),
        ∃ k,
          (((toEndomorphism R (↥⊤) M) { val := a, property := b } -
                  (χ ∘ ⇑(LieSubalgebra.incl ⊤)) { val := a, property := b } • 1) ^
                k)
              m =
            0) ↔
      ∃ k, (((toEndomorphism R L M) a - χ a • 1) ^ k) m = 0

Next tactic:
simp
@[simp]
theorem zero_weightSpace_eq_top_of_nilpotent [IsNilpotent R L M] :
    weightSpace M (0 : (⊤ : LieSubalgebra R L) → R) = ⊤ := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent R L M
⊢ weightSpace M 0 = ⊤

Next tactic:
ext m
@[simp]
theorem zero_weightSpace_eq_top_of_nilpotent [IsNilpotent R L M] :
    weightSpace M (0 : (⊤ : LieSubalgebra R L) → R) = ⊤ := by
  ext m
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent R L M
m : M
⊢ m ∈ weightSpace M 0 ↔ m ∈ ⊤

Next tactic:
simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero, Subtype.forall, forall_true_left,
    LieSubalgebra.toEndomorphism_mk, LieSubalgebra.mem_top, LieSubmodule.mem_top, iff_true]
@[simp]
theorem zero_weightSpace_eq_top_of_nilpotent [IsNilpotent R L M] :
    weightSpace M (0 : (⊤ : LieSubalgebra R L) → R) = ⊤ := by
  ext m
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero, Subtype.forall, forall_true_left,
    LieSubalgebra.toEndomorphism_mk, LieSubalgebra.mem_top, LieSubmodule.mem_top, iff_true]
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent R L M
m : M
⊢ ∀ (a : L), ∃ k, ((toEndomorphism R L M) a ^ k) m = 0

Next tactic:
intro x
@[simp]
theorem zero_weightSpace_eq_top_of_nilpotent [IsNilpotent R L M] :
    weightSpace M (0 : (⊤ : LieSubalgebra R L) → R) = ⊤ := by
  ext m
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero, Subtype.forall, forall_true_left,
    LieSubalgebra.toEndomorphism_mk, LieSubalgebra.mem_top, LieSubmodule.mem_top, iff_true]
  intro x
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent R L M
m : M
x : L
⊢ ∃ k, ((toEndomorphism R L M) x ^ k) m = 0

Next tactic:
obtain ⟨k, hk⟩ := exists_forall_pow_toEndomorphism_eq_zero R L M
@[simp]
theorem zero_weightSpace_eq_top_of_nilpotent [IsNilpotent R L M] :
    weightSpace M (0 : (⊤ : LieSubalgebra R L) → R) = ⊤ := by
  ext m
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero, Subtype.forall, forall_true_left,
    LieSubalgebra.toEndomorphism_mk, LieSubalgebra.mem_top, LieSubmodule.mem_top, iff_true]
  intro x
  obtain ⟨k, hk⟩ := exists_forall_pow_toEndomorphism_eq_zero R L M
  

Proof state:
case h.intro
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent R L M
m : M
x : L
k : ℕ
hk : ∀ (x : L), (toEndomorphism R L M) x ^ k = 0
⊢ ∃ k, ((toEndomorphism R L M) x ^ k) m = 0

Next tactic:
exact ⟨k, by simp [hk x]⟩
@[simp]
theorem zero_weightSpace_eq_top_of_nilpotent [IsNilpotent R L M] :
    weightSpace M (0 : (⊤ : LieSubalgebra R L) → R) = ⊤ := by
  ext m
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero, Subtype.forall, forall_true_left,
    LieSubalgebra.toEndomorphism_mk, LieSubalgebra.mem_top, LieSubmodule.mem_top, iff_true]
  intro x
  obtain ⟨k, hk⟩ := exists_forall_pow_toEndomorphism_eq_zero R L M
  exact ⟨k, by 

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNilpotent R L M
m : M
x : L
k : ℕ
hk : ∀ (x : L), (toEndomorphism R L M) x ^ k = 0
⊢ ((toEndomorphism R L M) x ^ k) m = 0

Next tactic:
simp [hk x]
theorem exists_weightSpace_le_ker_of_isNoetherian [IsNoetherian R M] (χ : L → R) (x : L) :
    ∃ k : ℕ,
      weightSpace M χ ≤ LinearMap.ker ((toEndomorphism R L M x - algebraMap R _ (χ x)) ^ k) := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
⊢ ∃ k, ↑(weightSpace M χ) ≤ LinearMap.ker (((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^ k)

Next tactic:
use (toEndomorphism R L M x).maximalGeneralizedEigenspaceIndex (χ x)
theorem exists_weightSpace_le_ker_of_isNoetherian [IsNoetherian R M] (χ : L → R) (x : L) :
    ∃ k : ℕ,
      weightSpace M χ ≤ LinearMap.ker ((toEndomorphism R L M x - algebraMap R _ (χ x)) ^ k) := by
  use (toEndomorphism R L M x).maximalGeneralizedEigenspaceIndex (χ x)
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
⊢ ↑(weightSpace M χ) ≤
    LinearMap.ker
      (((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^
        Module.End.maximalGeneralizedEigenspaceIndex ((toEndomorphism R L M) x) (χ x))

Next tactic:
intro m hm
theorem exists_weightSpace_le_ker_of_isNoetherian [IsNoetherian R M] (χ : L → R) (x : L) :
    ∃ k : ℕ,
      weightSpace M χ ≤ LinearMap.ker ((toEndomorphism R L M x - algebraMap R _ (χ x)) ^ k) := by
  use (toEndomorphism R L M x).maximalGeneralizedEigenspaceIndex (χ x)
  intro m hm
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
m : M
hm : m ∈ ↑(weightSpace M χ)
⊢ m ∈
    LinearMap.ker
      (((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^
        Module.End.maximalGeneralizedEigenspaceIndex ((toEndomorphism R L M) x) (χ x))

Next tactic:
replace hm : m ∈ (toEndomorphism R L M x).maximalGeneralizedEigenspace (χ x) :=
    weightSpace_le_weightSpaceOf M x χ hm
theorem exists_weightSpace_le_ker_of_isNoetherian [IsNoetherian R M] (χ : L → R) (x : L) :
    ∃ k : ℕ,
      weightSpace M χ ≤ LinearMap.ker ((toEndomorphism R L M x - algebraMap R _ (χ x)) ^ k) := by
  use (toEndomorphism R L M x).maximalGeneralizedEigenspaceIndex (χ x)
  intro m hm
  replace hm : m ∈ (toEndomorphism R L M x).maximalGeneralizedEigenspace (χ x) :=
    weightSpace_le_weightSpaceOf M x χ hm
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
m : M
hm : m ∈ Module.End.maximalGeneralizedEigenspace ((toEndomorphism R L M) x) (χ x)
⊢ m ∈
    LinearMap.ker
      (((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^
        Module.End.maximalGeneralizedEigenspaceIndex ((toEndomorphism R L M) x) (χ x))

Next tactic:
rwa [Module.End.maximalGeneralizedEigenspace_eq] at hm
variable (R) in
theorem exists_weightSpace_zero_le_ker_of_isNoetherian
    [IsNoetherian R M] (x : L) :
    ∃ k : ℕ, weightSpace M (0 : L → R) ≤ LinearMap.ker (toEndomorphism R L M x ^ k) := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
x : L
⊢ ∃ k, ↑(weightSpace M 0) ≤ LinearMap.ker ((toEndomorphism R L M) x ^ k)

Next tactic:
simpa using exists_weightSpace_le_ker_of_isNoetherian M (0 : L → R) x
lemma isNilpotent_toEndomorphism_sub_algebraMap [IsNoetherian R M] (χ : L → R) (x : L) :
    _root_.IsNilpotent <| toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
⊢ _root_.IsNilpotent
    ((toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x))

Next tactic:
have : toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) =
      (toEndomorphism R L M x - algebraMap R _ (χ x)).restrict
        (fun m hm ↦ sub_mem (LieSubmodule.lie_mem _ hm) (Submodule.smul_mem _ _ hm)) := by
    rfl
lemma isNilpotent_toEndomorphism_sub_algebraMap [IsNoetherian R M] (χ : L → R) (x : L) :
    _root_.IsNilpotent <| toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) := by
  have : toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) =
      (toEndomorphism R L M x - algebraMap R _ (χ x)).restrict
        (fun m hm ↦ sub_mem (LieSubmodule.lie_mem _ hm) (Submodule.smul_mem _ _ hm)) := by
    

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
⊢ (toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x) =
    LinearMap.restrict ((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x))
      (_ :
        ∀ m ∈ ↑(weightSpace M χ),
          ((toEndomorphism R L M) x) m - ((algebraMap R (Module.End R M)) (χ x)) m ∈ ↑(weightSpace M χ))

Next tactic:
rfl
lemma isNilpotent_toEndomorphism_sub_algebraMap [IsNoetherian R M] (χ : L → R) (x : L) :
    _root_.IsNilpotent <| toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) := by
  have : toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) =
      (toEndomorphism R L M x - algebraMap R _ (χ x)).restrict
        (fun m hm ↦ sub_mem (LieSubmodule.lie_mem _ hm) (Submodule.smul_mem _ _ hm)) := by
    rfl
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
this :
  (toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x) =
    LinearMap.restrict ((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x))
      (_ :
        ∀ m ∈ ↑(weightSpace M χ),
          ((toEndomorphism R L M) x) m - ((algebraMap R (Module.End R M)) (χ x)) m ∈ ↑(weightSpace M χ))
⊢ _root_.IsNilpotent
    ((toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x))

Next tactic:
obtain ⟨k, hk⟩ := exists_weightSpace_le_ker_of_isNoetherian M χ x
lemma isNilpotent_toEndomorphism_sub_algebraMap [IsNoetherian R M] (χ : L → R) (x : L) :
    _root_.IsNilpotent <| toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) := by
  have : toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) =
      (toEndomorphism R L M x - algebraMap R _ (χ x)).restrict
        (fun m hm ↦ sub_mem (LieSubmodule.lie_mem _ hm) (Submodule.smul_mem _ _ hm)) := by
    rfl
  obtain ⟨k, hk⟩ := exists_weightSpace_le_ker_of_isNoetherian M χ x
  

Proof state:
case intro
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
this :
  (toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x) =
    LinearMap.restrict ((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x))
      (_ :
        ∀ m ∈ ↑(weightSpace M χ),
          ((toEndomorphism R L M) x) m - ((algebraMap R (Module.End R M)) (χ x)) m ∈ ↑(weightSpace M χ))
k : ℕ
hk : ↑(weightSpace M χ) ≤ LinearMap.ker (((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^ k)
⊢ _root_.IsNilpotent
    ((toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x))

Next tactic:
use k
lemma isNilpotent_toEndomorphism_sub_algebraMap [IsNoetherian R M] (χ : L → R) (x : L) :
    _root_.IsNilpotent <| toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) := by
  have : toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) =
      (toEndomorphism R L M x - algebraMap R _ (χ x)).restrict
        (fun m hm ↦ sub_mem (LieSubmodule.lie_mem _ hm) (Submodule.smul_mem _ _ hm)) := by
    rfl
  obtain ⟨k, hk⟩ := exists_weightSpace_le_ker_of_isNoetherian M χ x
  use k
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
this :
  (toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x) =
    LinearMap.restrict ((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x))
      (_ :
        ∀ m ∈ ↑(weightSpace M χ),
          ((toEndomorphism R L M) x) m - ((algebraMap R (Module.End R M)) (χ x)) m ∈ ↑(weightSpace M χ))
k : ℕ
hk : ↑(weightSpace M χ) ≤ LinearMap.ker (((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^ k)
⊢ ((toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x)) ^ k = 0

Next tactic:
ext ⟨m, hm⟩
lemma isNilpotent_toEndomorphism_sub_algebraMap [IsNoetherian R M] (χ : L → R) (x : L) :
    _root_.IsNilpotent <| toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) := by
  have : toEndomorphism R L (weightSpace M χ) x - algebraMap R _ (χ x) =
      (toEndomorphism R L M x - algebraMap R _ (χ x)).restrict
        (fun m hm ↦ sub_mem (LieSubmodule.lie_mem _ hm) (Submodule.smul_mem _ _ hm)) := by
    rfl
  obtain ⟨k, hk⟩ := exists_weightSpace_le_ker_of_isNoetherian M χ x
  use k
  ext ⟨m, hm⟩
  

Proof state:
case h.h.mk.a
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
χ : L → R
x : L
this :
  (toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x) =
    LinearMap.restrict ((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x))
      (_ :
        ∀ m ∈ ↑(weightSpace M χ),
          ((toEndomorphism R L M) x) m - ((algebraMap R (Module.End R M)) (χ x)) m ∈ ↑(weightSpace M χ))
k : ℕ
hk : ↑(weightSpace M χ) ≤ LinearMap.ker (((toEndomorphism R L M) x - (algebraMap R (Module.End R M)) (χ x)) ^ k)
m : M
hm : m ∈ ↑(weightSpace M χ)
⊢ ↑((((toEndomorphism R L ↥↑(weightSpace M χ)) x - (algebraMap R (Module.End R ↥↑(weightSpace M χ))) (χ x)) ^ k)
        { val := m, property := hm }) =
    ↑(0 { val := m, property := hm })

Next tactic:
simpa [this, LinearMap.pow_restrict _, LinearMap.restrict_apply] using hk hm
/-- A (nilpotent) Lie algebra acts nilpotently on the zero weight space of a Noetherian Lie
module. -/
theorem isNilpotent_toEndomorphism_weightSpace_zero [IsNoetherian R M] (x : L) :
    _root_.IsNilpotent <| toEndomorphism R L (weightSpace M (0 : L → R)) x := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
x : L
⊢ _root_.IsNilpotent ((toEndomorphism R L ↥↑(weightSpace M 0)) x)

Next tactic:
simpa using isNilpotent_toEndomorphism_sub_algebraMap M (0 : L → R) x
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ LieSubmodule.normalizer (weightSpace M 0) = weightSpace M 0

Next tactic:
refine' le_antisymm _ (LieSubmodule.le_normalizer _)
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  refine' le_antisymm _ (LieSubmodule.le_normalizer _)
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ LieSubmodule.normalizer (weightSpace M 0) ≤ weightSpace M 0

Next tactic:
intro m hm
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  refine' le_antisymm _ (LieSubmodule.le_normalizer _)
  intro m hm
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
m : M
hm : m ∈ LieSubmodule.normalizer (weightSpace M 0)
⊢ m ∈ weightSpace M 0

Next tactic:
rw [LieSubmodule.mem_normalizer] at hm
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  refine' le_antisymm _ (LieSubmodule.le_normalizer _)
  intro m hm
  rw [LieSubmodule.mem_normalizer] at hm
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
m : M
hm : ∀ (x : L), ⁅x, m⁆ ∈ weightSpace M 0
⊢ m ∈ weightSpace M 0

Next tactic:
simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero] at hm ⊢
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  refine' le_antisymm _ (LieSubmodule.le_normalizer _)
  intro m hm
  rw [LieSubmodule.mem_normalizer] at hm
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero] at hm ⊢
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
m : M
hm : ∀ (x x_1 : L), ∃ k, ((toEndomorphism R L M) x_1 ^ k) ⁅x, m⁆ = 0
⊢ ∀ (x : L), ∃ k, ((toEndomorphism R L M) x ^ k) m = 0

Next tactic:
intro y
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  refine' le_antisymm _ (LieSubmodule.le_normalizer _)
  intro m hm
  rw [LieSubmodule.mem_normalizer] at hm
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero] at hm ⊢
  intro y
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
m : M
hm : ∀ (x x_1 : L), ∃ k, ((toEndomorphism R L M) x_1 ^ k) ⁅x, m⁆ = 0
y : L
⊢ ∃ k, ((toEndomorphism R L M) y ^ k) m = 0

Next tactic:
obtain ⟨k, hk⟩ := hm y y
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  refine' le_antisymm _ (LieSubmodule.le_normalizer _)
  intro m hm
  rw [LieSubmodule.mem_normalizer] at hm
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero] at hm ⊢
  intro y
  obtain ⟨k, hk⟩ := hm y y
  

Proof state:
case intro
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
m : M
hm : ∀ (x x_1 : L), ∃ k, ((toEndomorphism R L M) x_1 ^ k) ⁅x, m⁆ = 0
y : L
k : ℕ
hk : ((toEndomorphism R L M) y ^ k) ⁅y, m⁆ = 0
⊢ ∃ k, ((toEndomorphism R L M) y ^ k) m = 0

Next tactic:
use k + 1
@[simp]
lemma weightSpace_zero_normalizer_eq_self :
    (weightSpace M (0 : L → R)).normalizer = weightSpace M 0 := by
  refine' le_antisymm _ (LieSubmodule.le_normalizer _)
  intro m hm
  rw [LieSubmodule.mem_normalizer] at hm
  simp only [mem_weightSpace, Pi.zero_apply, zero_smul, sub_zero] at hm ⊢
  intro y
  obtain ⟨k, hk⟩ := hm y y
  use k + 1
  

Proof state:
case h
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
m : M
hm : ∀ (x x_1 : L), ∃ k, ((toEndomorphism R L M) x_1 ^ k) ⁅x, m⁆ = 0
y : L
k : ℕ
hk : ((toEndomorphism R L M) y ^ k) ⁅y, m⁆ = 0
⊢ ((toEndomorphism R L M) y ^ (k + 1)) m = 0

Next tactic:
simpa [pow_succ', LinearMap.mul_eq_comp]
lemma iSup_ucs_le_weightSpace_zero :
    ⨆ k, (⊥ : LieSubmodule R L M).ucs k ≤ weightSpace M (0 : L → R) := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁷ : CommRing R
inst✝⁶ : LieRing L
inst✝⁵ : LieAlgebra R L
inst✝⁴ : LieAlgebra.IsNilpotent R L
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : LieRingModule L M
inst✝ : LieModule R L M
⊢ ⨆ k, LieSubmodule.ucs k ⊥ ≤ weightSpace M 0

Next tactic:
simpa using LieSubmodule.ucs_le_of_normalizer_eq_self (weightSpace_zero_normalizer_eq_self R L M)
/-- See also `LieModule.iInf_lowerCentralSeries_eq_posFittingComp`. -/
lemma iSup_ucs_eq_weightSpace_zero [IsNoetherian R M] :
    ⨆ k, (⊥ : LieSubmodule R L M).ucs k = weightSpace M (0 : L → R) := by
  

Proof state:
K : Type u_1
R : Type u_2
L : Type u_3
M : Type u_4
inst✝⁸ : CommRing R
inst✝⁷ : LieRing L
inst✝⁶ : LieAlgebra R L
inst✝⁵ : LieAlgebra.IsNilpotent R L
inst✝⁴ : AddCommGroup M
inst✝³ : Module R M
inst✝² : LieRingModule L M
inst✝¹ : LieModule R L M
inst✝ : IsNoetherian R M
⊢ ⨆ k, LieSubmodule.ucs k ⊥ = weightSpace M 0

Next tactic:
obtain ⟨k, hk⟩ := (LieSubmodule.isNilpotent_iff_exists_self_le_ucs
    <| weightSpace M (0 : L → R)).mp inferInstance