File: Mathlib/GroupTheory/Coxeter/Length.lean

full_name: CoxeterSystem._aux_Mathlib_GroupTheory_Coxeter_Length___macroRules_CoxeterSystem_termS__1
code: local prefix:100 "s" => cs.simple
goal: Lean.Macro

full_name: CoxeterSystem._aux_Mathlib_GroupTheory_Coxeter_Length___macroRules_CoxeterSystem_termπ__1
code: local prefix:100 "π" => cs.wordProd
goal: Lean.Macro

full_name: _private.Mathlib.GroupTheory.Coxeter.Length.0.CoxeterSystem.exists_word_with_prod
code: private theorem exists_word_with_prod (w : W) : ∃ n ω, ω.length = n ∧ π ω = w 
goal: ∃ n ω, ω.length = n ∧ cs.wordProd ω = w

full_name: CoxeterSystem.length
code: /-- The length of `w`; i.e., the minimum number of simple reflections that
must be multiplied to form `w`. -/
noncomputable def length (w : W) : ℕ 
goal: ℕ

full_name: CoxeterSystem._aux_Mathlib_GroupTheory_Coxeter_Length___macroRules_CoxeterSystem_termℓ__1
code: local prefix:100 "ℓ" => cs.length
goal: Lean.Macro

full_name: CoxeterSystem.exists_reduced_word
code: theorem exists_reduced_word (w : W) : ∃ ω, ω.length = ℓ w ∧ w = π ω 
goal: ∃ ω, ω.length = cs.length w ∧ w = cs.wordProd ω

full_name: CoxeterSystem.length_wordProd_le
code: theorem length_wordProd_le (ω : List B) : ℓ (π ω) ≤ ω.length 
goal: cs.length (cs.wordProd ω) ≤ ω.length

full_name: CoxeterSystem.length_one
code: @[simp] theorem length_one : ℓ (1 : W) = 0 
goal: cs.length 1 = 0

full_name: CoxeterSystem.length_eq_zero_iff
code: @[simp]
theorem length_eq_zero_iff {w : W} : ℓ w = 0 ↔ w = 1 
goal: cs.length w = 0 ↔ w = 1

full_name: CoxeterSystem.length_inv
code: @[simp]
theorem length_inv (w : W) : ℓ (w⁻¹) = ℓ w 
goal: cs.length w⁻¹ = cs.length w

full_name: CoxeterSystem.length_mul_le
code: theorem length_mul_le (w₁ w₂ : W) :
    ℓ (w₁ * w₂) ≤ ℓ w₁ + ℓ w₂ 
goal: cs.length (w₁ * w₂) ≤ cs.length w₁ + cs.length w₂

full_name: CoxeterSystem.length_mul_ge_length_sub_length
code: theorem length_mul_ge_length_sub_length (w₁ w₂ : W) :
    ℓ w₁ - ℓ w₂ ≤ ℓ (w₁ * w₂) 
goal: cs.length w₁ - cs.length w₂ ≤ cs.length (w₁ * w₂)

full_name: CoxeterSystem.length_mul_ge_length_sub_length'
code: theorem length_mul_ge_length_sub_length' (w₁ w₂ : W) :
    ℓ w₂ - ℓ w₁ ≤ ℓ (w₁ * w₂) 
goal: cs.length w₂ - cs.length w₁ ≤ cs.length (w₁ * w₂)

full_name: CoxeterSystem.length_mul_ge_max
code: theorem length_mul_ge_max (w₁ w₂ : W) :
    max (ℓ w₁ - ℓ w₂) (ℓ w₂ - ℓ w₁) ≤ ℓ (w₁ * w₂) 
goal: max (cs.length w₁ - cs.length w₂) (cs.length w₂ - cs.length w₁) ≤ cs.length (w₁ * w₂)

full_name: CoxeterSystem.lengthParity
code: /-- The homomorphism that sends each element `w : W` to the parity of the length of `w`.
(See `lengthParity_eq_ofAdd_length`.) -/
def lengthParity : W →* Multiplicative (ZMod 2) 
goal: W →* Multiplicative (ZMod 2)

full_name: CoxeterSystem.lengthParity_simple
code: theorem lengthParity_simple (i : B) :
    cs.lengthParity (s i) = Multiplicative.ofAdd 1 
goal: cs.lengthParity (cs.simple i) = Multiplicative.ofAdd 1

full_name: CoxeterSystem.lengthParity_comp_simple
code: theorem lengthParity_comp_simple :
    cs.lengthParity ∘ cs.simple = fun _ ↦ Multiplicative.ofAdd 1 
goal: ⇑cs.lengthParity ∘ cs.simple = fun x => Multiplicative.ofAdd 1

full_name: CoxeterSystem.lengthParity_eq_ofAdd_length
code: theorem lengthParity_eq_ofAdd_length (w : W) :
    cs.lengthParity w = Multiplicative.ofAdd (↑(ℓ w)) 
goal: cs.lengthParity w = Multiplicative.ofAdd ↑(cs.length w)

full_name: CoxeterSystem.length_mul_mod_two
code: theorem length_mul_mod_two (w₁ w₂ : W) : ℓ (w₁ * w₂) % 2 = (ℓ w₁ + ℓ w₂) % 2 
goal: cs.length (w₁ * w₂) % 2 = (cs.length w₁ + cs.length w₂) % 2

full_name: CoxeterSystem.length_simple
code: @[simp]
theorem length_simple (i : B) : ℓ (s i) = 1 
goal: cs.length (cs.simple i) = 1

full_name: CoxeterSystem.length_eq_one_iff
code: theorem length_eq_one_iff {w : W} : ℓ w = 1 ↔ ∃ i : B, w = s i 
goal: cs.length w = 1 ↔ ∃ i, w = cs.simple i

full_name: CoxeterSystem.length_mul_simple_ne
code: theorem length_mul_simple_ne (w : W) (i : B) : ℓ (w * s i) ≠ ℓ w 
goal: cs.length (w * cs.simple i) ≠ cs.length w

full_name: CoxeterSystem.length_simple_mul_ne
code: theorem length_simple_mul_ne (w : W) (i : B) : ℓ (s i * w) ≠ ℓ w 
goal: cs.length (cs.simple i * w) ≠ cs.length w

full_name: CoxeterSystem.length_mul_simple
code: theorem length_mul_simple (w : W) (i : B) :
    ℓ (w * s i) = ℓ w + 1 ∨ ℓ (w * s i) + 1 = ℓ w 
goal: cs.length (w * cs.simple i) = cs.length w + 1 ∨ cs.length (w * cs.simple i) + 1 = cs.length w

full_name: CoxeterSystem.length_simple_mul
code: theorem length_simple_mul (w : W) (i : B) :
    ℓ (s i * w) = ℓ w + 1 ∨ ℓ (s i * w) + 1 = ℓ w 
goal: cs.length (cs.simple i * w) = cs.length w + 1 ∨ cs.length (cs.simple i * w) + 1 = cs.length w

full_name: CoxeterSystem.IsReduced
code: /-- The proposition that `ω` is reduced; that is, it has minimal length among all words that
represent the same element of `W`. -/
def IsReduced (ω : List B) : Prop 
goal: Prop

full_name: CoxeterSystem.isReduced_reverse
code: @[simp]
theorem isReduced_reverse (ω : List B) : cs.IsReduced (ω.reverse) ↔ cs.IsReduced ω 
goal: cs.IsReduced ω.reverse ↔ cs.IsReduced ω

full_name: CoxeterSystem.exists_reduced_word'
code: theorem exists_reduced_word' (w : W) : ∃ ω : List B, cs.IsReduced ω ∧ w = π ω 
goal: ∃ ω, cs.IsReduced ω ∧ w = cs.wordProd ω

full_name: _private.Mathlib.GroupTheory.Coxeter.Length.0.CoxeterSystem.isReduced_take_and_drop
code: private theorem isReduced_take_and_drop {ω : List B} (hω : cs.IsReduced ω) (j : ℕ) :
    cs.IsReduced (ω.take j) ∧ cs.IsReduced (ω.drop j) 
goal: cs.IsReduced (List.take j ω) ∧ cs.IsReduced (List.drop j ω)

full_name: CoxeterSystem.isReduced_take
code: theorem isReduced_take {ω : List B} (hω : cs.IsReduced ω) (j : ℕ) : cs.IsReduced (ω.take j) 
goal: cs.IsReduced (List.take j ω)

full_name: CoxeterSystem.isReduced_drop
code: theorem isReduced_drop {ω : List B} (hω : cs.IsReduced ω) (j : ℕ) : cs.IsReduced (ω.drop j) 
goal: cs.IsReduced (List.drop j ω)

full_name: CoxeterSystem.not_isReduced_alternatingWord
code: theorem not_isReduced_alternatingWord (i i' : B) {m : ℕ} (hM : M i i' ≠ 0) (hm : m > M i i') :
    ¬cs.IsReduced (alternatingWord i i' m) 
goal: ¬cs.IsReduced (CoxeterSystem.alternatingWord i i' m)

full_name: CoxeterSystem.IsLeftDescent
code: /-- The proposition that `i` is a left descent of `w`; that is, $\ell(s_i w) < \ell(w)$. -/
def IsLeftDescent (w : W) (i : B) : Prop 
goal: Prop

full_name: CoxeterSystem.IsRightDescent
code: /-- The proposition that `i` is a right descent of `w`; that is, $\ell(w s_i) < \ell(w)$. -/
def IsRightDescent (w : W) (i : B) : Prop 
goal: Prop

full_name: CoxeterSystem.not_isLeftDescent_one
code: theorem not_isLeftDescent_one (i : B) : ¬cs.IsLeftDescent 1 i 
goal: ¬cs.IsLeftDescent 1 i

full_name: CoxeterSystem.not_isRightDescent_one
code: theorem not_isRightDescent_one (i : B) : ¬cs.IsRightDescent 1 i 
goal: ¬cs.IsRightDescent 1 i

full_name: CoxeterSystem.isLeftDescent_inv_iff
code: theorem isLeftDescent_inv_iff {w : W} {i : B} :
    cs.IsLeftDescent w⁻¹ i ↔ cs.IsRightDescent w i 
goal: cs.IsLeftDescent w⁻¹ i ↔ cs.IsRightDescent w i

full_name: CoxeterSystem.isRightDescent_inv_iff
code: theorem isRightDescent_inv_iff {w : W} {i : B} :
    cs.IsRightDescent w⁻¹ i ↔ cs.IsLeftDescent w i 
goal: cs.IsRightDescent w⁻¹ i ↔ cs.IsLeftDescent w i

full_name: CoxeterSystem.exists_leftDescent_of_ne_one
code: theorem exists_leftDescent_of_ne_one {w : W} (hw : w ≠ 1) : ∃ i : B, cs.IsLeftDescent w i 
goal: ∃ i, cs.IsLeftDescent w i

full_name: CoxeterSystem.exists_rightDescent_of_ne_one
code: theorem exists_rightDescent_of_ne_one {w : W} (hw : w ≠ 1) : ∃ i : B, cs.IsRightDescent w i 
goal: ∃ i, cs.IsRightDescent w i

full_name: CoxeterSystem.isLeftDescent_iff
code: theorem isLeftDescent_iff {w : W} {i : B} :
    cs.IsLeftDescent w i ↔ ℓ (s i * w) + 1 = ℓ w 
goal: cs.IsLeftDescent w i ↔ cs.length (cs.simple i * w) + 1 = cs.length w

full_name: CoxeterSystem.not_isLeftDescent_iff
code: theorem not_isLeftDescent_iff {w : W} {i : B} :
    ¬cs.IsLeftDescent w i ↔ ℓ (s i * w) = ℓ w + 1 
goal: ¬cs.IsLeftDescent w i ↔ cs.length (cs.simple i * w) = cs.length w + 1

full_name: CoxeterSystem.isRightDescent_iff
code: theorem isRightDescent_iff {w : W} {i : B} :
    cs.IsRightDescent w i ↔ ℓ (w * s i) + 1 = ℓ w 
goal: cs.IsRightDescent w i ↔ cs.length (w * cs.simple i) + 1 = cs.length w

full_name: CoxeterSystem.not_isRightDescent_iff
code: theorem not_isRightDescent_iff {w : W} {i : B} :
    ¬cs.IsRightDescent w i ↔ ℓ (w * s i) = ℓ w + 1 
goal: ¬cs.IsRightDescent w i ↔ cs.length (w * cs.simple i) = cs.length w + 1

full_name: CoxeterSystem.isLeftDescent_iff_not_isLeftDescent_mul
code: theorem isLeftDescent_iff_not_isLeftDescent_mul {w : W} {i : B} :
    cs.IsLeftDescent w i ↔ ¬cs.IsLeftDescent (s i * w) i 
goal: cs.IsLeftDescent w i ↔ ¬cs.IsLeftDescent (cs.simple i * w) i

full_name: CoxeterSystem.isRightDescent_iff_not_isRightDescent_mul
code: theorem isRightDescent_iff_not_isRightDescent_mul {w : W} {i : B} :
    cs.IsRightDescent w i ↔ ¬cs.IsRightDescent (w * s i) i 
goal: cs.IsRightDescent w i ↔ ¬cs.IsRightDescent (w * cs.simple i) i