File: Mathlib/GroupTheory/Coxeter/Inversion.lean

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

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

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

full_name: CoxeterSystem.IsReflection
code: /-- `t : W` is a *reflection* of the Coxeter system `cs` if it is of the form
$w s_i w^{-1}$, where $w \in W$ and $s_i$ is a simple reflection. -/
def IsReflection (t : W) : Prop 
goal: Prop

full_name: CoxeterSystem.isReflection_simple
code: theorem isReflection_simple (i : B) : cs.IsReflection (s i) 
goal: cs.IsReflection (cs.simple i)

full_name: CoxeterSystem.IsReflection.pow_two
code: theorem pow_two : t ^ 2 = 1 
goal: t ^ 2 = 1

full_name: CoxeterSystem.IsReflection.mul_self
code: theorem mul_self : t * t = 1 
goal: t * t = 1

full_name: CoxeterSystem.IsReflection.inv
code: theorem inv : t⁻¹ = t 
goal: t⁻¹ = t

full_name: CoxeterSystem.IsReflection.isReflection_inv
code: theorem isReflection_inv : cs.IsReflection t⁻¹ 
goal: cs.IsReflection t⁻¹

full_name: CoxeterSystem.IsReflection.odd_length
code: theorem odd_length : Odd (ℓ t) 
goal: Odd (cs.length t)

full_name: CoxeterSystem.IsReflection.length_mul_left_ne
code: theorem length_mul_left_ne (w : W) : ℓ (w * t) ≠ ℓ w 
goal: cs.length (w * t) ≠ cs.length w

full_name: CoxeterSystem.IsReflection.length_mul_right_ne
code: theorem length_mul_right_ne (w : W) : ℓ (t * w) ≠ ℓ w 
goal: cs.length (t * w) ≠ cs.length w

full_name: CoxeterSystem.IsReflection.conj
code: theorem conj (w : W) : cs.IsReflection (w * t * w⁻¹) 
goal: cs.IsReflection (w * t * w⁻¹)

full_name: CoxeterSystem.isReflection_conj_iff
code: @[simp]
theorem isReflection_conj_iff (w t : W) :
    cs.IsReflection (w * t * w⁻¹) ↔ cs.IsReflection t 
goal: cs.IsReflection (w * t * w⁻¹) ↔ cs.IsReflection t

full_name: CoxeterSystem.IsRightInversion
code: /-- The proposition that `t` is a right inversion of `w`; i.e., `t` is a reflection and
$\ell (w t) < \ell(w)$. -/
def IsRightInversion (w t : W) : Prop 
goal: Prop

full_name: CoxeterSystem.IsLeftInversion
code: /-- The proposition that `t` is a left inversion of `w`; i.e., `t` is a reflection and
$\ell (t w) < \ell(w)$. -/
def IsLeftInversion (w t : W) : Prop 
goal: Prop

full_name: CoxeterSystem.isRightInversion_inv_iff
code: theorem isRightInversion_inv_iff {w t : W} :
    cs.IsRightInversion w⁻¹ t ↔ cs.IsLeftInversion w t 
goal: cs.IsRightInversion w⁻¹ t ↔ cs.IsLeftInversion w t

full_name: CoxeterSystem.isLeftInversion_inv_iff
code: theorem isLeftInversion_inv_iff {w t : W} :
    cs.IsLeftInversion w⁻¹ t ↔ cs.IsRightInversion w t 
goal: cs.IsLeftInversion w⁻¹ t ↔ cs.IsRightInversion w t

full_name: CoxeterSystem.IsReflection.isRightInversion_mul_left_iff
code: theorem isRightInversion_mul_left_iff {w : W} :
    cs.IsRightInversion (w * t) t ↔ ¬cs.IsRightInversion w t 
goal: cs.IsRightInversion (w * t) t ↔ ¬cs.IsRightInversion w t

full_name: CoxeterSystem.IsReflection.not_isRightInversion_mul_left_iff
code: theorem not_isRightInversion_mul_left_iff {w : W} :
    ¬cs.IsRightInversion (w * t) t ↔ cs.IsRightInversion w t 
goal: ¬cs.IsRightInversion (w * t) t ↔ cs.IsRightInversion w t

full_name: CoxeterSystem.IsReflection.isLeftInversion_mul_right_iff
code: theorem isLeftInversion_mul_right_iff {w : W} :
    cs.IsLeftInversion (t * w) t ↔ ¬cs.IsLeftInversion w t 
goal: cs.IsLeftInversion (t * w) t ↔ ¬cs.IsLeftInversion w t

full_name: CoxeterSystem.IsReflection.not_isLeftInversion_mul_right_iff
code: theorem not_isLeftInversion_mul_right_iff {w : W}  :
    ¬cs.IsLeftInversion (t * w) t ↔ cs.IsLeftInversion w t 
goal: ¬cs.IsLeftInversion (t * w) t ↔ cs.IsLeftInversion w t

full_name: CoxeterSystem.isRightInversion_simple_iff_isRightDescent
code: @[simp]
theorem isRightInversion_simple_iff_isRightDescent (w : W) (i : B) :
    cs.IsRightInversion w (s i) ↔ cs.IsRightDescent w i 
goal: cs.IsRightInversion w (cs.simple i) ↔ cs.IsRightDescent w i

full_name: CoxeterSystem.isLeftInversion_simple_iff_isLeftDescent
code: @[simp]
theorem isLeftInversion_simple_iff_isLeftDescent (w : W) (i : B) :
    cs.IsLeftInversion w (s i) ↔ cs.IsLeftDescent w i 
goal: cs.IsLeftInversion w (cs.simple i) ↔ cs.IsLeftDescent w i

full_name: CoxeterSystem.rightInvSeq
code: /-- The right inversion sequence of `ω`. The right inversion sequence of a word
$s_{i_1} \cdots s_{i_\ell}$ is the sequence
$$s_{i_\ell}\cdots s_{i_1}\cdots s_{i_\ell}, \ldots,
    s_{i_{\ell}}s_{i_{\ell - 1}}s_{i_{\ell - 2}}s_{i_{\ell - 1}}s_{i_\ell}, \ldots,
    s_{i_{\ell}}s_{i_{\ell - 1}}s_{i_\ell}, s_{i_\ell}.$$
-/
def rightInvSeq (ω : List B) : List W 
goal: List W

full_name: CoxeterSystem.leftInvSeq
code: /-- The left inversion sequence of `ω`. The left inversion sequence of a word
$s_{i_1} \cdots s_{i_\ell}$ is the sequence
$$s_{i_1}, s_{i_1}s_{i_2}s_{i_1}, s_{i_1}s_{i_2}s_{i_3}s_{i_2}s_{i_1}, \ldots,
    s_{i_1}\cdots s_{i_\ell}\cdots s_{i_1}.$$
-/
def leftInvSeq (ω : List B) : List W 
goal: List W

full_name: CoxeterSystem._aux_Mathlib_GroupTheory_Coxeter_Inversion___macroRules_CoxeterSystem_termRis__1
code: local prefix:100 "ris" => cs.rightInvSeq
goal: Lean.Macro

full_name: CoxeterSystem._aux_Mathlib_GroupTheory_Coxeter_Inversion___macroRules_CoxeterSystem_termLis__1
code: local prefix:100 "lis" => cs.leftInvSeq
goal: Lean.Macro

full_name: CoxeterSystem.rightInvSeq_nil
code: @[simp] theorem rightInvSeq_nil : ris [] = [] 
goal: cs.rightInvSeq [] = []

full_name: CoxeterSystem.leftInvSeq_nil
code: @[simp] theorem leftInvSeq_nil : lis [] = [] 
goal: cs.leftInvSeq [] = []

full_name: CoxeterSystem.rightInvSeq_singleton
code: @[simp] theorem rightInvSeq_singleton (i : B) : ris [i] = [s i] 
goal: cs.rightInvSeq [i] = [cs.simple i]

full_name: CoxeterSystem.leftInvSeq_singleton
code: @[simp] theorem leftInvSeq_singleton (i : B) : lis [i] = [s i] 
goal: cs.leftInvSeq [i] = [cs.simple i]

full_name: CoxeterSystem.rightInvSeq_concat
code: theorem rightInvSeq_concat (ω : List B) (i : B) :
    ris (ω.concat i) = (List.map (MulAut.conj (s i)) (ris ω)).concat (s i) 
goal: cs.rightInvSeq (ω.concat i) = (List.map (⇑(MulAut.conj (cs.simple i))) (cs.rightInvSeq ω)).concat (cs.simple i)

full_name: _private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.leftInvSeq_eq_reverse_rightInvSeq_reverse
code: private theorem leftInvSeq_eq_reverse_rightInvSeq_reverse (ω : List B) :
    lis ω = (ris ω.reverse).reverse 
goal: cs.leftInvSeq ω = (cs.rightInvSeq ω.reverse).reverse

full_name: CoxeterSystem.leftInvSeq_concat
code: theorem leftInvSeq_concat (ω : List B) (i : B) :
    lis (ω.concat i) = (lis ω).concat ((π ω) * (s i) * (π ω)⁻¹) 
goal: cs.leftInvSeq (ω.concat i) = (cs.leftInvSeq ω).concat (cs.wordProd ω * cs.simple i * (cs.wordProd ω)⁻¹)

full_name: CoxeterSystem.rightInvSeq_reverse
code: theorem rightInvSeq_reverse (ω : List B) :
    ris (ω.reverse) = (lis ω).reverse 
goal: cs.rightInvSeq ω.reverse = (cs.leftInvSeq ω).reverse

full_name: CoxeterSystem.leftInvSeq_reverse
code: theorem leftInvSeq_reverse (ω : List B) :
    lis (ω.reverse) = (ris ω).reverse 
goal: cs.leftInvSeq ω.reverse = (cs.rightInvSeq ω).reverse

full_name: CoxeterSystem.length_rightInvSeq
code: @[simp] theorem length_rightInvSeq (ω : List B) : (ris ω).length = ω.length 
goal: (cs.rightInvSeq ω).length = ω.length

full_name: CoxeterSystem.length_leftInvSeq
code: @[simp] theorem length_leftInvSeq (ω : List B) : (lis ω).length = ω.length 
goal: (cs.leftInvSeq ω).length = ω.length

full_name: CoxeterSystem.getD_rightInvSeq
code: theorem getD_rightInvSeq (ω : List B) (j : ℕ) :
    (ris ω).getD j 1 =
      (π (ω.drop (j + 1)))⁻¹
        * (Option.map (cs.simple) (ω.get? j)).getD 1
        * π (ω.drop (j + 1)) 
goal: (cs.rightInvSeq ω).getD j 1 =
  (cs.wordProd (List.drop (j + 1) ω))⁻¹ * (Option.map cs.simple (ω.get? j)).getD 1 * cs.wordProd (List.drop (j + 1) ω)

full_name: CoxeterSystem.getD_leftInvSeq
code: theorem getD_leftInvSeq (ω : List B) (j : ℕ) :
    (lis ω).getD j 1 =
      π (ω.take j)
        * (Option.map (cs.simple) (ω.get? j)).getD 1
        * (π (ω.take j))⁻¹ 
goal: (cs.leftInvSeq ω).getD j 1 =
  cs.wordProd (List.take j ω) * (Option.map cs.simple (ω.get? j)).getD 1 * (cs.wordProd (List.take j ω))⁻¹

full_name: CoxeterSystem.getD_rightInvSeq_mul_self
code: theorem getD_rightInvSeq_mul_self (ω : List B) (j : ℕ) :
    ((ris ω).getD j 1) * ((ris ω).getD j 1) = 1 
goal: (cs.rightInvSeq ω).getD j 1 * (cs.rightInvSeq ω).getD j 1 = 1

full_name: CoxeterSystem.getD_leftInvSeq_mul_self
code: theorem getD_leftInvSeq_mul_self (ω : List B) (j : ℕ) :
    ((lis ω).getD j 1) * ((lis ω).getD j 1) = 1 
goal: (cs.leftInvSeq ω).getD j 1 * (cs.leftInvSeq ω).getD j 1 = 1

full_name: CoxeterSystem.rightInvSeq_drop
code: theorem rightInvSeq_drop (ω : List B) (j : ℕ) :
    ris (ω.drop j) = (ris ω).drop j 
goal: cs.rightInvSeq (List.drop j ω) = List.drop j (cs.rightInvSeq ω)

full_name: CoxeterSystem.leftInvSeq_take
code: theorem leftInvSeq_take (ω : List B) (j : ℕ) :
    lis (ω.take j) = (lis ω).take j 
goal: cs.leftInvSeq (List.take j ω) = List.take j (cs.leftInvSeq ω)

full_name: CoxeterSystem.isReflection_of_mem_rightInvSeq
code: theorem isReflection_of_mem_rightInvSeq (ω : List B) {t : W} (ht : t ∈ ris ω) :
    cs.IsReflection t 
goal: cs.IsReflection t

full_name: CoxeterSystem.isReflection_of_mem_leftInvSeq
code: theorem isReflection_of_mem_leftInvSeq (ω : List B) {t : W} (ht : t ∈ lis ω) :
    cs.IsReflection t 
goal: cs.IsReflection t

full_name: CoxeterSystem.wordProd_mul_getD_rightInvSeq
code: theorem wordProd_mul_getD_rightInvSeq (ω : List B) (j : ℕ) :
    π ω * ((ris ω).getD j 1) = π (ω.eraseIdx j) 
goal: cs.wordProd ω * (cs.rightInvSeq ω).getD j 1 = cs.wordProd (ω.eraseIdx j)

full_name: CoxeterSystem.getD_leftInvSeq_mul_wordProd
code: theorem getD_leftInvSeq_mul_wordProd (ω : List B) (j : ℕ) :
    ((lis ω).getD j 1) * π ω = π (ω.eraseIdx j) 
goal: (cs.leftInvSeq ω).getD j 1 * cs.wordProd ω = cs.wordProd (ω.eraseIdx j)

full_name: CoxeterSystem.isRightInversion_of_mem_rightInvSeq
code: theorem isRightInversion_of_mem_rightInvSeq {ω : List B} (hω : cs.IsReduced ω) {t : W}
    (ht : t ∈ ris ω) : cs.IsRightInversion (π ω) t 
goal: cs.IsRightInversion (cs.wordProd ω) t

full_name: CoxeterSystem.isLeftInversion_of_mem_leftInvSeq
code: theorem isLeftInversion_of_mem_leftInvSeq {ω : List B} (hω : cs.IsReduced ω) {t : W}
    (ht : t ∈ lis ω) : cs.IsLeftInversion (π ω) t 
goal: cs.IsLeftInversion (cs.wordProd ω) t

full_name: CoxeterSystem.prod_rightInvSeq
code: theorem prod_rightInvSeq (ω : List B) : prod (ris ω) = (π ω)⁻¹ 
goal: (cs.rightInvSeq ω).prod = (cs.wordProd ω)⁻¹

full_name: CoxeterSystem.prod_leftInvSeq
code: theorem prod_leftInvSeq (ω : List B) : prod (lis ω) = (π ω)⁻¹ 
goal: (cs.leftInvSeq ω).prod = (cs.wordProd ω)⁻¹

full_name: CoxeterSystem.IsReduced.nodup_rightInvSeq
code: theorem IsReduced.nodup_rightInvSeq {ω : List B} (rω : cs.IsReduced ω) : List.Nodup (ris ω) 
goal: (cs.rightInvSeq ω).Nodup

full_name: CoxeterSystem.IsReduced.nodup_leftInvSeq
code: theorem IsReduced.nodup_leftInvSeq {ω : List B} (rω : cs.IsReduced ω) : List.Nodup (lis ω) 
goal: (cs.leftInvSeq ω).Nodup