File: Mathlib/Algebra/Lie/Weights/Chain.lean

full_name: LieModule.eventually_weightSpace_smul_add_eq_bot
code: lemma eventually_weightSpace_smul_add_eq_bot :
    ∀ᶠ (k : ℕ) in Filter.atTop, weightSpace M (k • χ₁ + χ₂) = ⊥ 
goal: ∀ᶠ (k : ℕ) in Filter.atTop, LieModule.weightSpace M (k • χ₁ + χ₂) = ⊥

full_name: LieModule.exists_weightSpace_smul_add_eq_bot
code: lemma exists_weightSpace_smul_add_eq_bot :
    ∃ k > 0, weightSpace M (k • χ₁ + χ₂) = ⊥ 
goal: ∃ k > 0, LieModule.weightSpace M (k • χ₁ + χ₂) = ⊥

full_name: LieModule.exists₂_weightSpace_smul_add_eq_bot
code: lemma exists₂_weightSpace_smul_add_eq_bot :
    ∃ᵉ (p < (0 : ℤ)) (q > (0 : ℤ)),
      weightSpace M (p • χ₁ + χ₂) = ⊥ ∧
      weightSpace M (q • χ₁ + χ₂) = ⊥ 
goal: ∃ p < 0, ∃ q > 0, LieModule.weightSpace M (p • χ₁ + χ₂) = ⊥ ∧ LieModule.weightSpace M (q • χ₁ + χ₂) = ⊥

full_name: LieModule.weightSpaceChain
code: /-- Given two (potential) weights `χ₁` and `χ₂` together with integers `p` and `q`, it is often
useful to study the sum of weight spaces associated to the family of weights `k • χ₁ + χ₂` for
`p < k < q`. -/
def weightSpaceChain : LieSubmodule R L M 
goal: LieSubmodule R L M

full_name: LieModule.weightSpaceChain_def
code: lemma weightSpaceChain_def :
    weightSpaceChain M χ₁ χ₂ p q = ⨆ k ∈ Ioo p q, weightSpace M (k • χ₁ + χ₂) 
goal: LieModule.weightSpaceChain M χ₁ χ₂ p q = ⨆ k ∈ Set.Ioo p q, LieModule.weightSpace M (k • χ₁ + χ₂)

full_name: LieModule.weightSpaceChain_def'
code: lemma weightSpaceChain_def' :
    weightSpaceChain M χ₁ χ₂ p q = ⨆ k ∈ Finset.Ioo p q, weightSpace M (k • χ₁ + χ₂) 
goal: LieModule.weightSpaceChain M χ₁ χ₂ p q = ⨆ k ∈ Finset.Ioo p q, LieModule.weightSpace M (k • χ₁ + χ₂)

full_name: LieModule.weightSpaceChain_neg
code: @[simp]
lemma weightSpaceChain_neg :
    weightSpaceChain M (-χ₁) χ₂ (-q) (-p) = weightSpaceChain M χ₁ χ₂ p q 
goal: LieModule.weightSpaceChain M (-χ₁) χ₂ (-q) (-p) = LieModule.weightSpaceChain M χ₁ χ₂ p q

full_name: LieModule.weightSpace_le_weightSpaceChain
code: lemma weightSpace_le_weightSpaceChain {k : ℤ} (hk : k ∈ Ioo p q) :
    weightSpace M (k • χ₁ + χ₂) ≤ weightSpaceChain M χ₁ χ₂ p q 
goal: LieModule.weightSpace M (k • χ₁ + χ₂) ≤ LieModule.weightSpaceChain M χ₁ χ₂ p q

full_name: LieModule.lie_mem_weightSpaceChain_of_weightSpace_eq_bot_right
code: lemma lie_mem_weightSpaceChain_of_weightSpace_eq_bot_right [LieAlgebra.IsNilpotent R H]
    (hq : weightSpace M (q • α + χ) = ⊥)
    {x : L} (hx : x ∈ rootSpace H α)
    {y : M} (hy : y ∈ weightSpaceChain M α χ p q) :
    ⁅x, y⁆ ∈ weightSpaceChain M α χ p q 
goal: ⁅x, y⁆ ∈ LieModule.weightSpaceChain M α χ p q

full_name: LieModule.lie_mem_weightSpaceChain_of_weightSpace_eq_bot_left
code: lemma lie_mem_weightSpaceChain_of_weightSpace_eq_bot_left [LieAlgebra.IsNilpotent R H]
    (hp : weightSpace M (p • α + χ) = ⊥)
    {x : L} (hx : x ∈ rootSpace H (-α))
    {y : M} (hy : y ∈ weightSpaceChain M α χ p q) :
    ⁅x, y⁆ ∈ weightSpaceChain M α χ p q 
goal: ⁅x, y⁆ ∈ LieModule.weightSpaceChain M α χ p q

full_name: LieModule.trace_toEnd_weightSpaceChain_eq_zero
code: lemma trace_toEnd_weightSpaceChain_eq_zero
    (hp : weightSpace M (p • α + χ) = ⊥)
    (hq : weightSpace M (q • α + χ) = ⊥)
    {x : H} (hx : x ∈ corootSpace α) :
    LinearMap.trace R _ (toEnd R H (weightSpaceChain M α χ p q) x) = 0 
goal: (LinearMap.trace R ↥↑(LieModule.weightSpaceChain M α χ p q))
    ((LieModule.toEnd R ↥H ↥↑(LieModule.weightSpaceChain M α χ p q)) x) =
  0

full_name: LieModule.exists_forall_mem_corootSpace_smul_add_eq_zero
code: /-- Given a (potential) root `α` relative to a Cartan subalgebra `H`, if we restrict to the ideal
`I = corootSpace α` of `H` (informally, `I = ⁅H(α), H(-α)⁆`), we may find an
integral linear combination between `α` and any weight `χ` of a representation.

This is Proposition 4.4 from [carter2005] and is a key step in the proof that the roots of a
semisimple Lie algebra form a root system. It shows that the restriction of `α` to `I` vanishes iff
the restriction of every root to `I` vanishes (which cannot happen in a semisimple Lie algebra). -/
lemma exists_forall_mem_corootSpace_smul_add_eq_zero
    [IsDomain R] [IsPrincipalIdealRing R] [CharZero R] [NoZeroSMulDivisors R M] [IsNoetherian R M]
    (hα : α ≠ 0) (hχ : weightSpace M χ ≠ ⊥) :
    ∃ a b : ℤ, 0 < b ∧ ∀ x ∈ corootSpace α, (a • α + b • χ) x = 0 
goal: ∃ a b, 0 < b ∧ ∀ x ∈ LieAlgebra.corootSpace α, (a • α + b • χ) x = 0

full_name: LieModule.chainTopCoeff
code: /-- This is the largest `n : ℕ` such that `i • α + β` is a weight for all `0 ≤ i ≤ n`. -/
noncomputable
def chainTopCoeff : ℕ 
goal: ℕ

full_name: LieModule.chainBotCoeff
code: /-- This is the largest `n : ℕ` such that `-i • α + β` is a weight for all `0 ≤ i ≤ n`. -/
noncomputable
def chainBotCoeff : ℕ 
goal: ℕ

full_name: LieModule.chainTopCoeff_neg
code: @[simp] lemma chainTopCoeff_neg : chainTopCoeff (-α) β = chainBotCoeff α β 
goal: LieModule.chainTopCoeff (-α) β = LieModule.chainBotCoeff α β

full_name: LieModule.chainBotCoeff_neg
code: @[simp] lemma chainBotCoeff_neg : chainBotCoeff (-α) β = chainTopCoeff α β 
goal: LieModule.chainBotCoeff (-α) β = LieModule.chainTopCoeff α β

full_name: LieModule.chainTopCoeff_zero
code: @[simp] lemma chainTopCoeff_zero : chainTopCoeff 0 β = 0 
goal: LieModule.chainTopCoeff 0 β = 0

full_name: LieModule.chainBotCoeff_zero
code: @[simp] lemma chainBotCoeff_zero : chainBotCoeff 0 β = 0 
goal: LieModule.chainBotCoeff 0 β = 0

full_name: LieModule.chainTopCoeff_add_one
code: lemma chainTopCoeff_add_one :
    letI := Classical.propDecidable
    chainTopCoeff α β + 1 =
      Nat.find (eventually_weightSpace_smul_add_eq_bot M α β hα).exists 
goal: LieModule.chainTopCoeff α β + 1 = Nat.find ⋯

full_name: LieModule.weightSpace_chainTopCoeff_add_one_nsmul_add
code: lemma weightSpace_chainTopCoeff_add_one_nsmul_add :
    weightSpace M ((chainTopCoeff α β + 1) • α + β : L → R) = ⊥ 
goal: LieModule.weightSpace M ((LieModule.chainTopCoeff α β + 1) • α + ⇑β) = ⊥

full_name: LieModule.weightSpace_chainTopCoeff_add_one_zsmul_add
code: lemma weightSpace_chainTopCoeff_add_one_zsmul_add :
    weightSpace M ((chainTopCoeff α β + 1 : ℤ) • α + β : L → R) = ⊥ 
goal: LieModule.weightSpace M ((↑(LieModule.chainTopCoeff α β) + 1) • α + ⇑β) = ⊥

full_name: LieModule.weightSpace_nsmul_add_ne_bot_of_le
code: lemma weightSpace_nsmul_add_ne_bot_of_le {n} (hn : n ≤ chainTopCoeff α β) :
    weightSpace M (n • α + β : L → R) ≠ ⊥ 
goal: LieModule.weightSpace M (n • α + ⇑β) ≠ ⊥

full_name: LieModule.weightSpace_chainBotCoeff_sub_one_zsmul_sub
code: lemma weightSpace_chainBotCoeff_sub_one_zsmul_sub :
    weightSpace M ((-chainBotCoeff α β - 1 : ℤ) • α + β : L → R) = ⊥ 
goal: LieModule.weightSpace M ((-↑(LieModule.chainBotCoeff α β) - 1) • α + ⇑β) = ⊥

full_name: LieModule.weightSpace_zsmul_add_ne_bot
code: lemma weightSpace_zsmul_add_ne_bot {n : ℤ}
    (hn : -chainBotCoeff α β ≤ n) (hn' : n ≤ chainTopCoeff α β) :
      weightSpace M (n • α + β : L → R) ≠ ⊥ 
goal: LieModule.weightSpace M (n • α + ⇑β) ≠ ⊥

full_name: LieModule.weightSpace_neg_zsmul_add_ne_bot
code: lemma weightSpace_neg_zsmul_add_ne_bot {n : ℕ} (hn : n ≤ chainBotCoeff α β) :
    weightSpace M ((-n : ℤ) • α + β : L → R) ≠ ⊥ 
goal: LieModule.weightSpace M (-↑n • α + ⇑β) ≠ ⊥

full_name: LieModule.chainTop
code: /-- The last weight in an `α`-chain through `β`. -/
noncomputable
def chainTop (α : L → R) (β : Weight R L M) : Weight R L M 
goal: LieModule.Weight R L M

full_name: LieModule.chainBot
code: /-- The first weight in an `α`-chain through `β`. -/
noncomputable
def chainBot (α : L → R) (β : Weight R L M) : Weight R L M 
goal: LieModule.Weight R L M

full_name: LieModule.coe_chainTop'
code: lemma coe_chainTop' : (chainTop α β : L → R) = chainTopCoeff α β • α + β 
goal: ⇑(LieModule.chainTop α β) = LieModule.chainTopCoeff α β • α + ⇑β

full_name: LieModule.coe_chainTop
code: @[simp] lemma coe_chainTop : (chainTop α β : L → R) = (chainTopCoeff α β : ℤ) • α + β 
goal: ⇑(LieModule.chainTop α β) = ↑(LieModule.chainTopCoeff α β) • α + ⇑β

full_name: LieModule.coe_chainBot
code: @[simp] lemma coe_chainBot : (chainBot α β : L → R) = (-chainBotCoeff α β : ℤ) • α + β 
goal: ⇑(LieModule.chainBot α β) = -↑(LieModule.chainBotCoeff α β) • α + ⇑β

full_name: LieModule.chainTop_neg
code: @[simp] lemma chainTop_neg : chainTop (-α) β = chainBot α β 
goal: LieModule.chainTop (-α) β = LieModule.chainBot α β

full_name: LieModule.chainBot_neg
code: @[simp] lemma chainBot_neg : chainBot (-α) β = chainTop α β 
goal: LieModule.chainBot (-α) β = LieModule.chainTop α β

full_name: LieModule.chainTop_zero
code: @[simp] lemma chainTop_zero : chainTop 0 β = β 
goal: LieModule.chainTop 0 β = β

full_name: LieModule.chainBot_zero
code: @[simp] lemma chainBot_zero : chainBot 0 β = β 
goal: LieModule.chainBot 0 β = β

full_name: LieModule.weightSpace_add_chainTop
code: lemma weightSpace_add_chainTop :
    weightSpace M (α + chainTop α β : L → R) = ⊥ 
goal: LieModule.weightSpace M (α + ⇑(LieModule.chainTop α β)) = ⊥

full_name: LieModule.weightSpace_neg_add_chainBot
code: lemma weightSpace_neg_add_chainBot :
    weightSpace M (-α + chainBot α β : L → R) = ⊥ 
goal: LieModule.weightSpace M (-α + ⇑(LieModule.chainBot α β)) = ⊥

full_name: LieModule.chainTop_isNonZero'
code: lemma chainTop_isNonZero' (hα' : weightSpace M α ≠ ⊥) :
    (chainTop α β).IsNonZero 
goal: (LieModule.chainTop α β).IsNonZero

full_name: LieModule.chainTop_isNonZero
code: lemma chainTop_isNonZero (α β : Weight R L M) (hα : α.IsNonZero) :
    (chainTop α β).IsNonZero 
goal: (LieModule.chainTop (⇑α) β).IsNonZero