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

full_name: _private.Mathlib.Algebra.Lie.Weights.RootSystem.0.LieAlgebra.IsKilling.chainLength_aux
code: private lemma chainLength_aux {x} (hx : x ∈ rootSpace H (chainTop α β)) :
    ∃ n : ℕ, n • x = ⁅coroot α, x⁆ 
goal: ∃ n, n • x = ⁅LieAlgebra.IsKilling.coroot α, x⁆

full_name: LieAlgebra.IsKilling.chainLength
code: /-- The length of the `α`-chain through `β`. See `chainBotCoeff_add_chainTopCoeff`. -/
def chainLength (α β : Weight K H L) : ℕ 
goal: ℕ

full_name: LieAlgebra.IsKilling.chainLength_of_isZero
code: lemma chainLength_of_isZero (hα : α.IsZero) : chainLength α β = 0 
goal: LieAlgebra.IsKilling.chainLength α β = 0

full_name: LieAlgebra.IsKilling.chainLength_nsmul
code: lemma chainLength_nsmul {x} (hx : x ∈ rootSpace H (chainTop α β)) :
    chainLength α β • x = ⁅coroot α, x⁆ 
goal: LieAlgebra.IsKilling.chainLength α β • x = ⁅LieAlgebra.IsKilling.coroot α, x⁆

full_name: LieAlgebra.IsKilling.chainLength_smul
code: lemma chainLength_smul {x} (hx : x ∈ rootSpace H (chainTop α β)) :
    (chainLength α β : K) • x = ⁅coroot α, x⁆ 
goal: ↑(LieAlgebra.IsKilling.chainLength α β) • x = ⁅LieAlgebra.IsKilling.coroot α, x⁆

full_name: LieAlgebra.IsKilling.apply_coroot_eq_cast'
code: lemma apply_coroot_eq_cast' :
    β (coroot α) = ↑(chainLength α β - 2 * chainTopCoeff α β : ℤ) 
goal: β (LieAlgebra.IsKilling.coroot α) = ↑(↑(LieAlgebra.IsKilling.chainLength α β) - 2 * ↑(LieModule.chainTopCoeff (⇑α) β))

full_name: LieAlgebra.IsKilling.rootSpace_neg_nsmul_add_chainTop_of_le
code: lemma rootSpace_neg_nsmul_add_chainTop_of_le {n : ℕ} (hn : n ≤ chainLength α β) :
    rootSpace H (- (n • α) + chainTop α β) ≠ ⊥ 
goal: LieAlgebra.rootSpace H (-(n • ⇑α) + ⇑(LieModule.chainTop (⇑α) β)) ≠ ⊥

full_name: LieAlgebra.IsKilling.rootSpace_neg_nsmul_add_chainTop_of_lt
code: lemma rootSpace_neg_nsmul_add_chainTop_of_lt {n : ℕ} (hn : chainLength α β < n) :
    rootSpace H (- (n • α) + chainTop α β) = ⊥ 
goal: LieAlgebra.rootSpace H (-(n • ⇑α) + ⇑(LieModule.chainTop (⇑α) β)) = ⊥

full_name: LieAlgebra.IsKilling.chainTopCoeff_le_chainLength
code: lemma chainTopCoeff_le_chainLength : chainTopCoeff α β ≤ chainLength α β 
goal: LieModule.chainTopCoeff (⇑α) β ≤ LieAlgebra.IsKilling.chainLength α β

full_name: LieAlgebra.IsKilling.chainBotCoeff_add_chainTopCoeff
code: lemma chainBotCoeff_add_chainTopCoeff :
    chainBotCoeff α β + chainTopCoeff α β = chainLength α β 
goal: LieModule.chainBotCoeff (⇑α) β + LieModule.chainTopCoeff (⇑α) β = LieAlgebra.IsKilling.chainLength α β

full_name: LieAlgebra.IsKilling.chainTopCoeff_add_chainBotCoeff
code: lemma chainTopCoeff_add_chainBotCoeff :
    chainTopCoeff α β + chainBotCoeff α β = chainLength α β 
goal: LieModule.chainTopCoeff (⇑α) β + LieModule.chainBotCoeff (⇑α) β = LieAlgebra.IsKilling.chainLength α β

full_name: LieAlgebra.IsKilling.chainBotCoeff_le_chainLength
code: lemma chainBotCoeff_le_chainLength : chainBotCoeff α β ≤ chainLength α β 
goal: LieModule.chainBotCoeff (⇑α) β ≤ LieAlgebra.IsKilling.chainLength α β

full_name: LieAlgebra.IsKilling.chainLength_neg
code: @[simp]
lemma chainLength_neg :
    chainLength (-α) β = chainLength α β 
goal: LieAlgebra.IsKilling.chainLength (-α) β = LieAlgebra.IsKilling.chainLength α β

full_name: LieAlgebra.IsKilling.chainLength_zero
code: @[simp]
lemma chainLength_zero [Nontrivial L] : chainLength 0 β = 0 
goal: LieAlgebra.IsKilling.chainLength 0 β = 0

full_name: LieAlgebra.IsKilling.apply_coroot_eq_cast
code: /-- If `β - qα ... β ... β + rα` is the `α`-chain through `β`, then
  `β (coroot α) = q - r`. In particular, it is an integer. -/
lemma apply_coroot_eq_cast :
    β (coroot α) = (chainBotCoeff α β - chainTopCoeff α β : ℤ) 
goal: β (LieAlgebra.IsKilling.coroot α) = ↑(↑(LieModule.chainBotCoeff (⇑α) β) - ↑(LieModule.chainTopCoeff (⇑α) β))

full_name: LieAlgebra.IsKilling.le_chainBotCoeff_of_rootSpace_ne_top
code: lemma le_chainBotCoeff_of_rootSpace_ne_top (n : ℤ) (hn : rootSpace H (-n • α + β) ≠ ⊥) :
    n ≤ chainBotCoeff α β 
goal: n ≤ ↑(LieModule.chainBotCoeff (⇑α) β)

full_name: LieAlgebra.IsKilling.rootSpace_zsmul_add_ne_bot_iff
code: /-- Members of the `α`-chain through `β` are the only roots of the form `β - kα`. -/
lemma rootSpace_zsmul_add_ne_bot_iff (n : ℤ) :
    rootSpace H (n • α + β) ≠ ⊥ ↔ n ≤ chainTopCoeff α β ∧ -n ≤ chainBotCoeff α β 
goal: LieAlgebra.rootSpace H (n • ⇑α + ⇑β) ≠ ⊥ ↔
  n ≤ ↑(LieModule.chainTopCoeff (⇑α) β) ∧ -n ≤ ↑(LieModule.chainBotCoeff (⇑α) β)

full_name: LieAlgebra.IsKilling.rootSpace_zsmul_add_ne_bot_iff_mem
code: lemma rootSpace_zsmul_add_ne_bot_iff_mem (n : ℤ) :
    rootSpace H (n • α + β) ≠ ⊥ ↔ n ∈ Finset.Icc (-chainBotCoeff α β : ℤ) (chainTopCoeff α β) 
goal: LieAlgebra.rootSpace H (n • ⇑α + ⇑β) ≠ ⊥ ↔
  n ∈ Finset.Icc (-↑(LieModule.chainBotCoeff (⇑α) β)) ↑(LieModule.chainTopCoeff (⇑α) β)

full_name: LieAlgebra.IsKilling.chainTopCoeff_of_eq_zsmul_add
code: lemma chainTopCoeff_of_eq_zsmul_add (β' : Weight K H L) (n : ℤ) (hβ' : (β' : H → K) = n • α + β) :
    chainTopCoeff α β' = chainTopCoeff α β - n 
goal: ↑(LieModule.chainTopCoeff (⇑α) β') = ↑(LieModule.chainTopCoeff (⇑α) β) - n

full_name: LieAlgebra.IsKilling.chainBotCoeff_of_eq_zsmul_add
code: lemma chainBotCoeff_of_eq_zsmul_add (β' : Weight K H L) (n : ℤ) (hβ' : (β' : H → K) = n • α + β) :
    chainBotCoeff α β' = chainBotCoeff α β + n 
goal: ↑(LieModule.chainBotCoeff (⇑α) β') = ↑(LieModule.chainBotCoeff (⇑α) β) + n

full_name: LieAlgebra.IsKilling.chainLength_of_eq_zsmul_add
code: lemma chainLength_of_eq_zsmul_add (β' : Weight K H L) (n : ℤ) (hβ' : (β' : H → K) = n • α + β) :
    chainLength α β' = chainLength α β 
goal: LieAlgebra.IsKilling.chainLength α β' = LieAlgebra.IsKilling.chainLength α β

full_name: LieAlgebra.IsKilling.chainTopCoeff_zero_right
code: lemma chainTopCoeff_zero_right [Nontrivial L] :
    chainTopCoeff α (0 : Weight K H L) = 1 
goal: LieModule.chainTopCoeff (⇑α) 0 = 1

full_name: LieAlgebra.IsKilling.chainBotCoeff_zero_right
code: lemma chainBotCoeff_zero_right [Nontrivial L] : chainBotCoeff α (0 : Weight K H L) = 1 
goal: LieModule.chainBotCoeff (⇑α) 0 = 1

full_name: LieAlgebra.IsKilling.chainLength_zero_right
code: lemma chainLength_zero_right [Nontrivial L] : chainLength α 0 = 2 
goal: LieAlgebra.IsKilling.chainLength α 0 = 2

full_name: LieAlgebra.IsKilling.rootSpace_two_smul
code: lemma rootSpace_two_smul : rootSpace H (2 • α) = ⊥ 
goal: LieAlgebra.rootSpace H (2 • ⇑α) = ⊥

full_name: LieAlgebra.IsKilling.rootSpace_one_div_two_smul
code: lemma rootSpace_one_div_two_smul : rootSpace H ((2⁻¹ : K) • α) = ⊥ 
goal: LieAlgebra.rootSpace H (2⁻¹ • ⇑α) = ⊥

full_name: LieAlgebra.IsKilling.eq_neg_one_or_eq_zero_or_eq_one_of_eq_smul
code: lemma eq_neg_one_or_eq_zero_or_eq_one_of_eq_smul (k : K) (h : (β : H → K) = k • α) :
    k = -1 ∨ k = 0 ∨ k = 1 
goal: k = -1 ∨ k = 0 ∨ k = 1

full_name: LieAlgebra.IsKilling.eq_neg_or_eq_of_eq_smul
code: /-- `±α` are the only `K`-multiples of a root `α` that are also (non-zero) roots. -/
lemma eq_neg_or_eq_of_eq_smul (hβ : β.IsNonZero) (k : K) (h : (β : H → K) = k • α) :
    β = -α ∨ β = α 
goal: β = -α ∨ β = α

full_name: LieAlgebra.IsKilling.reflectRoot
code: /-- The reflection of a root along another. -/
def reflectRoot (α β : Weight K H L) : Weight K H L 
goal: LieModule.Weight K (↥H) L

full_name: LieAlgebra.IsKilling.reflectRoot_isNonZero
code: lemma reflectRoot_isNonZero (α β : Weight K H L) (hβ : β.IsNonZero) :
    (reflectRoot α β).IsNonZero 
goal: (LieAlgebra.IsKilling.reflectRoot α β).IsNonZero

full_name: LieAlgebra.IsKilling.rootSystem
code: /-- The root system of a finite-dimensional Lie algebra with non-degenerate Killing form over a
field of characteristic zero, relative to a splitting Cartan subalgebra. -/
def rootSystem :
    RootSystem {α : Weight K H L // α.IsNonZero} K (Dual K H) H 
goal: RootSystem { α // α.IsNonZero } K (Module.Dual K ↥H) ↥H

full_name: LieAlgebra.IsKilling.rootSystem_toLin_apply
code: @[simp] lemma rootSystem_toLin_apply (f x) : (rootSystem H).toLin f x = f x 
goal: ((LieAlgebra.IsKilling.rootSystem H).toLin f) x = f x

full_name: LieAlgebra.IsKilling.rootSystem_pairing_apply
code: @[simp] lemma rootSystem_pairing_apply (α β) : (rootSystem H).pairing β α = β.1 (coroot α.1) 
goal: (LieAlgebra.IsKilling.rootSystem H).pairing β α = ↑β (LieAlgebra.IsKilling.coroot ↑α)

full_name: LieAlgebra.IsKilling.rootSystem_root_apply
code: @[simp] lemma rootSystem_root_apply (α) : (rootSystem H).root α = α 
goal: (LieAlgebra.IsKilling.rootSystem H).root α = LieModule.Weight.toLinear K (↥H) L ↑α

full_name: LieAlgebra.IsKilling.rootSystem_coroot_apply
code: @[simp] lemma rootSystem_coroot_apply (α) : (rootSystem H).coroot α = coroot α 
goal: (LieAlgebra.IsKilling.rootSystem H).coroot α = LieAlgebra.IsKilling.coroot ↑α

full_name: LieAlgebra.IsKilling.isCrystallographic_rootSystem
code: theorem isCrystallographic_rootSystem : (rootSystem H).IsCrystallographic 
goal: (LieAlgebra.IsKilling.rootSystem H).IsCrystallographic

full_name: LieAlgebra.IsKilling.isReduced_rootSystem
code: theorem isReduced_rootSystem : (rootSystem H).IsReduced 
goal: (LieAlgebra.IsKilling.rootSystem H).IsReduced