ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
-- List.cycleType_formPerm
theorem cycleType_formPerm (hl : Nodup l) (hn : 2 ≤ l.length) :
    cycleType l.attach.formPerm = {l.length} 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} (hl : l.Nodup) (hn : 2 ≤ l.length)
Goal: l.attach.formPerm.cycleType = {l.length}
-- List.formPerm_apply_mem_eq_next
theorem formPerm_apply_mem_eq_next (hl : Nodup l) (x : α) (hx : x ∈ l) :
    formPerm l x = next l x hx 
Arguments: {α : Type u_1} [DecidableEq α] {l : List α} (hl : l.Nodup) (x : α) (hx : x ∈ l)
Goal: l.formPerm x = l.next x hx
-- Cycle.formPerm_coe
@[simp]
theorem formPerm_coe (l : List α) (hl : l.Nodup) : formPerm (l : Cycle α) hl = l.formPerm 
Arguments: {α : Type u_1} [DecidableEq α] (l : List α) (hl : l.Nodup)
Goal: (↑l).formPerm hl = l.formPerm
-- Cycle.formPerm_subsingleton
theorem formPerm_subsingleton (s : Cycle α) (h : Subsingleton s) : formPerm s h.nodup = 1 
Arguments: {α : Type u_1} [DecidableEq α] (s : Cycle α) (h : s.Subsingleton)
Goal: s.formPerm ⋯ = 1
-- Cycle.isCycle_formPerm
theorem isCycle_formPerm (s : Cycle α) (h : Nodup s) (hn : Nontrivial s) :
    IsCycle (formPerm s h) 
Arguments: {α : Type u_1} [DecidableEq α] (s : Cycle α) (h : s.Nodup) (hn : s.Nontrivial)
Goal: (s.formPerm h).IsCycle
-- Cycle.support_formPerm
theorem support_formPerm [Fintype α] (s : Cycle α) (h : Nodup s) (hn : Nontrivial s) :
    support (formPerm s h) = s.toFinset 
Arguments: {α : Type u_1} [DecidableEq α] [Fintype α] (s : Cycle α) (h : s.Nodup) (hn : s.Nontrivial)
Goal: (s.formPerm h).support = s.toFinset
-- Cycle.formPerm_eq_self_of_not_mem
theorem formPerm_eq_self_of_not_mem (s : Cycle α) (h : Nodup s) (x : α) (hx : x ∉ s) :
    formPerm s h x = x 
Arguments: {α : Type u_1} [DecidableEq α] (s : Cycle α) (h : s.Nodup) (x : α) (hx : x ∉ s)
Goal: (s.formPerm h) x = x
-- Cycle.formPerm_apply_mem_eq_next
theorem formPerm_apply_mem_eq_next (s : Cycle α) (h : Nodup s) (x : α) (hx : x ∈ s) :
    formPerm s h x = next s h x hx 
Arguments: {α : Type u_1} [DecidableEq α] (s : Cycle α) (h : s.Nodup) (x : α) (hx : x ∈ s)
Goal: (s.formPerm h) x = s.next h x hx
-- Cycle.formPerm_reverse
nonrec theorem formPerm_reverse (s : Cycle α) (h : Nodup s) :
    formPerm s.reverse (nodup_reverse_iff.mpr h) = (formPerm s h)⁻¹ 
Arguments: {α : Type u_1} [DecidableEq α] (s : Cycle α) (h : s.Nodup)
Goal: s.reverse.formPerm ⋯ = (s.formPerm h)⁻¹
-- Cycle.formPerm_eq_formPerm_iff
nonrec theorem formPerm_eq_formPerm_iff {α : Type*} [DecidableEq α] {s s' : Cycle α} {hs : s.Nodup}
    {hs' : s'.Nodup} :
    s.formPerm hs = s'.formPerm hs' ↔ s = s' ∨ s.Subsingleton ∧ s'.Subsingleton 
Arguments: {α : Type u_2} [DecidableEq α] {s s' : Cycle α} {hs : s.Nodup} {hs' : s'.Nodup}
Goal: s.formPerm hs = s'.formPerm hs' ↔ s = s' ∨ s.Subsingleton ∧ s'.Subsingleton
-- Equiv.Perm.toList_one
@[simp]
theorem toList_one : toList (1 : Perm α) x = [] 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (x : α)
Goal: Equiv.Perm.toList 1 x = []
-- Equiv.Perm.toList_eq_nil_iff
@[simp]
theorem toList_eq_nil_iff {p : Perm α} {x} : toList p x = [] ↔ x ∉ p.support 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {p : Equiv.Perm α} {x : α}
Goal: p.toList x = [] ↔ x ∉ p.support
-- Equiv.Perm.length_toList
@[simp]
theorem length_toList : length (toList p x) = (cycleOf p x).support.card 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α)
Goal: (p.toList x).length = (p.cycleOf x).support.card
-- Equiv.Perm.toList_ne_singleton
theorem toList_ne_singleton (y : α) : toList p x ≠ [y] 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x y : α)
Goal: p.toList x ≠ [y]
-- Equiv.Perm.two_le_length_toList_iff_mem_support
theorem two_le_length_toList_iff_mem_support {p : Perm α} {x : α} :
    2 ≤ length (toList p x) ↔ x ∈ p.support 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {p : Equiv.Perm α} {x : α}
Goal: 2 ≤ (p.toList x).length ↔ x ∈ p.support
-- Equiv.Perm.length_toList_pos_of_mem_support
theorem length_toList_pos_of_mem_support (h : x ∈ p.support) : 0 < length (toList p x) 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α) (h : x ∈ p.support)
Goal: 0 < (p.toList x).length
-- Equiv.Perm.get_toList
theorem get_toList (n : ℕ) (hn : n < length (toList p x)) :
    (toList p x).get ⟨n, hn⟩ = (p ^ n) x 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α) (n : ℕ) (hn : n < (p.toList x).length)
Goal: (p.toList x).get ⟨n, hn⟩ = (p ^ n) x
-- Equiv.Perm.toList_get_zero
theorem toList_get_zero (h : x ∈ p.support) :
    (toList p x).get ⟨0, (length_toList_pos_of_mem_support _ _ h)⟩ = x 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α) (h : x ∈ p.support)
Goal: (p.toList x).get ⟨0, ⋯⟩ = x
-- Equiv.Perm.nthLe_toList
@[deprecated get_toList (since := "2024-05-08")]
theorem nthLe_toList (n : ℕ) (hn : n < length (toList p x)) :
    (toList p x).nthLe n hn = (p ^ n) x 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α) (n : ℕ) (hn : n < (p.toList x).length)
Goal: (p.toList x).nthLe n hn = (p ^ n) x
-- Equiv.Perm.toList_nthLe_zero
@[deprecated toList_get_zero (since := "2024-05-08")]
theorem toList_nthLe_zero (h : x ∈ p.support) :
    (toList p x).nthLe 0 (length_toList_pos_of_mem_support _ _ h) = x 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α) (h : x ∈ p.support)
Goal: (p.toList x).nthLe 0 ⋯ = x
-- Equiv.Perm.mem_toList_iff
theorem mem_toList_iff {y : α} : y ∈ toList p x ↔ SameCycle p x y ∧ x ∈ p.support 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {p : Equiv.Perm α} {x y : α}
Goal: y ∈ p.toList x ↔ p.SameCycle x y ∧ x ∈ p.support
-- Equiv.Perm.nodup_toList
theorem nodup_toList (p : Perm α) (x : α) : Nodup (toList p x) 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α)
Goal: (p.toList x).Nodup
-- Equiv.Perm.next_toList_eq_apply
theorem next_toList_eq_apply (p : Perm α) (x y : α) (hy : y ∈ toList p x) :
    next (toList p x) y hy = p y 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x y : α) (hy : y ∈ p.toList x)
Goal: (p.toList x).next y hy = p y
-- Equiv.Perm.toList_pow_apply_eq_rotate
theorem toList_pow_apply_eq_rotate (p : Perm α) (x : α) (k : ℕ) :
    p.toList ((p ^ k) x) = (p.toList x).rotate k 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (p : Equiv.Perm α) (x : α) (k : ℕ)
Goal: p.toList ((p ^ k) x) = (p.toList x).rotate k
-- Equiv.Perm.SameCycle.toList_isRotated
theorem SameCycle.toList_isRotated {f : Perm α} {x y : α} (h : SameCycle f x y) :
    toList f x ~r toList f y 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {f : Equiv.Perm α} {x y : α} (h : f.SameCycle x y)
Goal: f.toList x ~r f.toList y
-- Equiv.Perm.pow_apply_mem_toList_iff_mem_support
theorem pow_apply_mem_toList_iff_mem_support {n : ℕ} : (p ^ n) x ∈ p.toList x ↔ x ∈ p.support 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] {p : Equiv.Perm α} {x : α} {n : ℕ}
Goal: (p ^ n) x ∈ p.toList x ↔ x ∈ p.support
-- Equiv.Perm.toList_formPerm_nil
theorem toList_formPerm_nil (x : α) : toList (formPerm ([] : List α)) x = [] 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (x : α)
Goal: [].formPerm.toList x = []
-- Equiv.Perm.toList_formPerm_singleton
theorem toList_formPerm_singleton (x y : α) : toList (formPerm [x]) y = [] 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (x y : α)
Goal: [x].formPerm.toList y = []
-- Equiv.Perm.toList_formPerm_nontrivial
theorem toList_formPerm_nontrivial (l : List α) (hl : 2 ≤ l.length) (hn : Nodup l) :
    toList (formPerm l) (l.get ⟨0, (zero_lt_two.trans_le hl)⟩) = l 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (l : List α) (hl : 2 ≤ l.length) (hn : l.Nodup)
Goal: l.formPerm.toList (l.get ⟨0, ⋯⟩) = l
-- Equiv.Perm.toList_formPerm_isRotated_self
theorem toList_formPerm_isRotated_self (l : List α) (hl : 2 ≤ l.length) (hn : Nodup l) (x : α)
    (hx : x ∈ l) : toList (formPerm l) x ~r l 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (l : List α) (hl : 2 ≤ l.length) (hn : l.Nodup) (x : α) (hx : x ∈ l)
Goal: l.formPerm.toList x ~r l
-- Equiv.Perm.formPerm_toList
theorem formPerm_toList (f : Perm α) (x : α) : formPerm (toList f x) = f.cycleOf x 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (f : Equiv.Perm α) (x : α)
Goal: (f.toList x).formPerm = f.cycleOf x
-- Equiv.Perm.toCycle_eq_toList
theorem toCycle_eq_toList (f : Perm α) (hf : IsCycle f) (x : α) (hx : f x ≠ x) :
    toCycle f hf = toList f x 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (f : Equiv.Perm α) (hf : f.IsCycle) (x : α) (hx : f x ≠ x)
Goal: f.toCycle hf = ↑(f.toList x)
-- Equiv.Perm.nodup_toCycle
theorem nodup_toCycle (f : Perm α) (hf : IsCycle f) : (toCycle f hf).Nodup 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (f : Equiv.Perm α) (hf : f.IsCycle)
Goal: (f.toCycle hf).Nodup
-- Equiv.Perm.nontrivial_toCycle
theorem nontrivial_toCycle (f : Perm α) (hf : IsCycle f) : (toCycle f hf).Nontrivial 
Arguments: {α : Type u_1} [Fintype α] [DecidableEq α] (f : Equiv.Perm α) (hf : f.IsCycle)
Goal: (f.toCycle hf).Nontrivial
-- Equiv.Perm.IsCycle.existsUnique_cycle
theorem IsCycle.existsUnique_cycle {f : Perm α} (hf : IsCycle f) :
    ∃! s : Cycle α, ∃ h : s.Nodup, s.formPerm h = f 
Arguments: {α : Type u_1} [Finite α] [DecidableEq α] {f : Equiv.Perm α} (hf : f.IsCycle)
Goal: ∃! s, ∃ (h : s.Nodup), s.formPerm h = f
-- Equiv.Perm.IsCycle.existsUnique_cycle_subtype
theorem IsCycle.existsUnique_cycle_subtype {f : Perm α} (hf : IsCycle f) :
    ∃! s : { s : Cycle α // s.Nodup }, (s : Cycle α).formPerm s.prop = f 
Arguments: {α : Type u_1} [Finite α] [DecidableEq α] {f : Equiv.Perm α} (hf : f.IsCycle)
Goal: ∃! s, (↑s).formPerm ⋯ = f
-- Equiv.Perm.IsCycle.existsUnique_cycle_nontrivial_subtype
theorem IsCycle.existsUnique_cycle_nontrivial_subtype {f : Perm α} (hf : IsCycle f) :
    ∃! s : { s : Cycle α // s.Nodup ∧ s.Nontrivial }, (s : Cycle α).formPerm s.prop.left = f 
Arguments: {α : Type u_1} [Finite α] [DecidableEq α] {f : Equiv.Perm α} (hf : f.IsCycle)
Goal: ∃! s, (↑s).formPerm ⋯ = f
-- Functor.map_map
@[functor_norm]
theorem Functor.map_map (m : α → β) (g : β → γ) (x : f α) : g <$> m <$> x = (g ∘ m) <$> x 
Arguments: {α β γ : Type u} {f : Type u → Type v} [Functor f] [LawfulFunctor f] (m : α → β) (g : β → γ) (x : f α)
Goal: g <$> m <$> x = (g ∘ m) <$> x
-- pure_id'_seq
@[simp]
theorem pure_id'_seq (x : F α) : (pure fun x => x) <*> x = x 
Arguments: {α : Type u} {F : Type u → Type v} [Applicative F] [LawfulApplicative F] (x : F α)
Goal: (Seq.seq (pure fun x => x) fun x_1 => x) = x
-- seq_map_assoc
@[functor_norm]
theorem seq_map_assoc (x : F (α → β)) (f : γ → α) (y : F γ) :
    x <*> f <$> y = (· ∘ f) <$> x <*> y 
Arguments: {α β γ : Type u} {F : Type u → Type v} [Applicative F] [LawfulApplicative F] (x : F (α → β)) (f : γ → α) (y : F γ)
Goal: (Seq.seq x fun x => f <$> y) = Seq.seq ((fun x => x ∘ f) <$> x) fun x => y
-- map_seq
@[functor_norm]
theorem map_seq (f : β → γ) (x : F (α → β)) (y : F α) :
    f <$> (x <*> y) = (f ∘ ·) <$> x <*> y 
Arguments: {α β γ : Type u} {F : Type u → Type v} [Applicative F] [LawfulApplicative F] (f : β → γ) (x : F (α → β)) (y : F α)
Goal: (f <$> Seq.seq x fun x => y) = Seq.seq ((fun x => f ∘ x) <$> x) fun x => y
-- map_bind
theorem map_bind (x : m α) {g : α → m β} {f : β → γ} :
    f <$> (x >>= g) = x >>= fun a => f <$> g a 
Arguments: {α β γ : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] (x : m α) {g : α → m β} {f : β → γ}
Goal: f <$> (x >>= g) = do
  let a ← x
  f <$> g a
-- seq_bind_eq
theorem seq_bind_eq (x : m α) {g : β → m γ} {f : α → β} :
    f <$> x >>= g = x >>= g ∘ f 
Arguments: {α β γ : Type u} {m : Type u → Type v} [Monad m] [LawfulMonad m] (x : m α) {g : β → m γ} {f : α → β}
Goal: f <$> x >>= g = x >>= g ∘ f
-- fish_pure
@[functor_norm]
theorem fish_pure {α β} (f : α → m β) : f >=> pure = f 
Arguments: {m : Type u → Type v} [Monad m] [LawfulMonad m] {α : Type u_1} {β : Type u} (f : α → m β)
Goal: f >=> pure = f
-- fish_pipe
@[functor_norm]
theorem fish_pipe {α β} (f : α → m β) : pure >=> f = f 
Arguments: {m : Type u → Type v} [Monad m] [LawfulMonad m] {α β : Type u} (f : α → m β)
Goal: pure >=> f = f
-- fish_assoc
@[functor_norm]
theorem fish_assoc {α β γ φ} (f : α → m β) (g : β → m γ) (h : γ → m φ) :
    (f >=> g) >=> h = f >=> g >=> h 
Arguments: {m : Type u → Type v} [Monad m] [LawfulMonad m] {α : Type u_1} {β γ φ : Type u} (f : α → m β) (g : β → m γ) (h : γ → m φ)
Goal: (f >=> g) >=> h = f >=> g >=> h
-- joinM_map_map
theorem joinM_map_map {α β : Type u} (f : α → β) (a : m (m α)) :
    joinM (Functor.map f <$> a) = f <$> joinM a 
Arguments: {m : Type u → Type u} [Monad m] [LawfulMonad m] {α β : Type u} (f : α → β) (a : m (m α))
Goal: joinM (Functor.map f <$> a) = f <$> joinM a
-- joinM_map_joinM
theorem joinM_map_joinM {α : Type u} (a : m (m (m α))) : joinM (joinM <$> a) = joinM (joinM a) 
Arguments: {m : Type u → Type u} [Monad m] [LawfulMonad m] {α : Type u} (a : m (m (m α)))
Goal: joinM (joinM <$> a) = joinM (joinM a)
-- joinM_map_pure
@[simp]
theorem joinM_map_pure {α : Type u} (a : m α) : joinM (pure <$> a) = a 
Arguments: {m : Type u → Type u} [Monad m] [LawfulMonad m] {α : Type u} (a : m α)
Goal: joinM (pure <$> a) = a
-- joinM_pure
@[simp]
theorem joinM_pure {α : Type u} (a : m α) : joinM (pure a) = a 
Arguments: {m : Type u → Type u} [Monad m] [LawfulMonad m] {α : Type u} (a : m α)
Goal: joinM (pure a) = a
-- guard_true
@[simp]
theorem guard_true {h : Decidable True} : @guard F _ True h = pure () 
Arguments: {F : Type → Type v} [Alternative F] {h : Decidable True}
Goal: guard True = pure ()
-- guard_false
@[simp]
theorem guard_false {h : Decidable False} : @guard F _ False h = failure 
Arguments: {F : Type → Type v} [Alternative F] {h : Decidable False}
Goal: guard False = failure
-- CommApplicative.commutative_prod
class CommApplicative (m : Type u → Type v) [Applicative m] extends LawfulApplicative m : Prop where
    commutative_prod : ∀ {α β} (a : m α) (b : m β),
    Prod.mk <$> a <*> b = (fun (b : β) a => (a, b)) <$> b <*> a
Arguments: {m : Type u → Type v} [Applicative m] [self : CommApplicative m] {α β : Type u} (a : m α) (b : m β)
Goal: (Seq.seq (Prod.mk <$> a) fun x => b) = Seq.seq ((fun b a => (a, b)) <$> b) fun x => a
-- CommApplicative.commutative_map
theorem CommApplicative.commutative_map {m : Type u → Type v} [h : Applicative m]
    [CommApplicative m] {α β γ} (a : m α) (b : m β) {f : α → β → γ} :
  f <$> a <*> b = flip f <$> b <*> a 
Arguments: {m : Type u → Type v} [h : Applicative m] [CommApplicative m] {α β γ : Type u} (a : m α) (b : m β) {f : α → β → γ}
Goal: (Seq.seq (f <$> a) fun x => b) = Seq.seq (flip f <$> b) fun x => a
-- CoxeterSystem.isReflection_simple
theorem isReflection_simple (i : B) : cs.IsReflection (s i) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (i : B)
Goal: cs.IsReflection (cs.simple i)
-- CoxeterSystem.IsReflection.pow_two
theorem pow_two : t ^ 2 = 1 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t)
Goal: t ^ 2 = 1
-- CoxeterSystem.IsReflection.mul_self
theorem mul_self : t * t = 1 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t)
Goal: t * t = 1
-- CoxeterSystem.IsReflection.inv
theorem inv : t⁻¹ = t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t)
Goal: t⁻¹ = t
-- CoxeterSystem.IsReflection.isReflection_inv
theorem isReflection_inv : cs.IsReflection t⁻¹ 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t)
Goal: cs.IsReflection t⁻¹
-- CoxeterSystem.IsReflection.odd_length
theorem odd_length : Odd (ℓ t) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t)
Goal: Odd (cs.length t)
-- CoxeterSystem.IsReflection.length_mul_left_ne
theorem length_mul_left_ne (w : W) : ℓ (w * t) ≠ ℓ w 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t) (w : W)
Goal: cs.length (w * t) ≠ cs.length w
-- CoxeterSystem.IsReflection.length_mul_right_ne
theorem length_mul_right_ne (w : W) : ℓ (t * w) ≠ ℓ w 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t) (w : W)
Goal: cs.length (t * w) ≠ cs.length w
-- CoxeterSystem.IsReflection.conj
theorem conj (w : W) : cs.IsReflection (w * t * w⁻¹) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t) (w : W)
Goal: cs.IsReflection (w * t * w⁻¹)
-- CoxeterSystem.isReflection_conj_iff
@[simp]
theorem isReflection_conj_iff (w t : W) :
    cs.IsReflection (w * t * w⁻¹) ↔ cs.IsReflection t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (w t : W)
Goal: cs.IsReflection (w * t * w⁻¹) ↔ cs.IsReflection t
-- CoxeterSystem.isRightInversion_inv_iff
theorem isRightInversion_inv_iff {w t : W} :
    cs.IsRightInversion w⁻¹ t ↔ cs.IsLeftInversion w t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w t : W}
Goal: cs.IsRightInversion w⁻¹ t ↔ cs.IsLeftInversion w t
-- CoxeterSystem.isLeftInversion_inv_iff
theorem isLeftInversion_inv_iff {w t : W} :
    cs.IsLeftInversion w⁻¹ t ↔ cs.IsRightInversion w t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) {w t : W}
Goal: cs.IsLeftInversion w⁻¹ t ↔ cs.IsRightInversion w t
-- CoxeterSystem.IsReflection.isRightInversion_mul_left_iff
theorem isRightInversion_mul_left_iff {w : W} :
    cs.IsRightInversion (w * t) t ↔ ¬cs.IsRightInversion w t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t) {w : W}
Goal: cs.IsRightInversion (w * t) t ↔ ¬cs.IsRightInversion w t
-- CoxeterSystem.IsReflection.not_isRightInversion_mul_left_iff
theorem not_isRightInversion_mul_left_iff {w : W} :
    ¬cs.IsRightInversion (w * t) t ↔ cs.IsRightInversion w t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t) {w : W}
Goal: ¬cs.IsRightInversion (w * t) t ↔ cs.IsRightInversion w t
-- CoxeterSystem.IsReflection.isLeftInversion_mul_right_iff
theorem isLeftInversion_mul_right_iff {w : W} :
    cs.IsLeftInversion (t * w) t ↔ ¬cs.IsLeftInversion w t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t) {w : W}
Goal: cs.IsLeftInversion (t * w) t ↔ ¬cs.IsLeftInversion w t
-- CoxeterSystem.IsReflection.not_isLeftInversion_mul_right_iff
theorem not_isLeftInversion_mul_right_iff {w : W}  :
    ¬cs.IsLeftInversion (t * w) t ↔ cs.IsLeftInversion w t 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {t : W} (ht : cs.IsReflection t) {w : W}
Goal: ¬cs.IsLeftInversion (t * w) t ↔ cs.IsLeftInversion w t
-- CoxeterSystem.isRightInversion_simple_iff_isRightDescent
@[simp]
theorem isRightInversion_simple_iff_isRightDescent (w : W) (i : B) :
    cs.IsRightInversion w (s i) ↔ cs.IsRightDescent w i 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (w : W) (i : B)
Goal: cs.IsRightInversion w (cs.simple i) ↔ cs.IsRightDescent w i
-- CoxeterSystem.isLeftInversion_simple_iff_isLeftDescent
@[simp]
theorem isLeftInversion_simple_iff_isLeftDescent (w : W) (i : B) :
    cs.IsLeftInversion w (s i) ↔ cs.IsLeftDescent w i 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (w : W) (i : B)
Goal: cs.IsLeftInversion w (cs.simple i) ↔ cs.IsLeftDescent w i
-- CoxeterSystem.rightInvSeq_nil
@[simp] theorem rightInvSeq_nil : ris [] = [] 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W)
Goal: cs.rightInvSeq [] = []
-- CoxeterSystem.leftInvSeq_nil
@[simp] theorem leftInvSeq_nil : lis [] = [] 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W)
Goal: cs.leftInvSeq [] = []
-- CoxeterSystem.rightInvSeq_singleton
@[simp] theorem rightInvSeq_singleton (i : B) : ris [i] = [s i] 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (i : B)
Goal: cs.rightInvSeq [i] = [cs.simple i]
-- CoxeterSystem.leftInvSeq_singleton
@[simp] theorem leftInvSeq_singleton (i : B) : lis [i] = [s i] 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (i : B)
Goal: cs.leftInvSeq [i] = [cs.simple i]
-- CoxeterSystem.rightInvSeq_concat
theorem rightInvSeq_concat (ω : List B) (i : B) :
    ris (ω.concat i) = (List.map (MulAut.conj (s i)) (ris ω)).concat (s i) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (i : B)
Goal: cs.rightInvSeq (ω.concat i) = (List.map (⇑(MulAut.conj (cs.simple i))) (cs.rightInvSeq ω)).concat (cs.simple i)
-- _private.Mathlib.GroupTheory.Coxeter.Inversion.0.CoxeterSystem.leftInvSeq_eq_reverse_rightInvSeq_reverse
private theorem leftInvSeq_eq_reverse_rightInvSeq_reverse (ω : List B) :
    lis ω = (ris ω.reverse).reverse 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B)
Goal: cs.leftInvSeq ω = (cs.rightInvSeq ω.reverse).reverse
-- CoxeterSystem.leftInvSeq_concat
theorem leftInvSeq_concat (ω : List B) (i : B) :
    lis (ω.concat i) = (lis ω).concat ((π ω) * (s i) * (π ω)⁻¹) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (i : B)
Goal: cs.leftInvSeq (ω.concat i) = (cs.leftInvSeq ω).concat (cs.wordProd ω * cs.simple i * (cs.wordProd ω)⁻¹)
-- CoxeterSystem.rightInvSeq_reverse
theorem rightInvSeq_reverse (ω : List B) :
    ris (ω.reverse) = (lis ω).reverse 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B)
Goal: cs.rightInvSeq ω.reverse = (cs.leftInvSeq ω).reverse
-- CoxeterSystem.leftInvSeq_reverse
theorem leftInvSeq_reverse (ω : List B) :
    lis (ω.reverse) = (ris ω).reverse 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B)
Goal: cs.leftInvSeq ω.reverse = (cs.rightInvSeq ω).reverse
-- CoxeterSystem.length_rightInvSeq
@[simp] theorem length_rightInvSeq (ω : List B) : (ris ω).length = ω.length 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B)
Goal: (cs.rightInvSeq ω).length = ω.length
-- CoxeterSystem.length_leftInvSeq
@[simp] theorem length_leftInvSeq (ω : List B) : (lis ω).length = ω.length 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B)
Goal: (cs.leftInvSeq ω).length = ω.length
-- CoxeterSystem.getD_rightInvSeq
theorem getD_rightInvSeq (ω : List B) (j : ℕ) :
    (ris ω).getD j 1 =
      (π (ω.drop (j + 1)))⁻¹
        * (Option.map (cs.simple) (ω.get? j)).getD 1
        * π (ω.drop (j + 1)) 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (j : ℕ)
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) ω)
-- CoxeterSystem.getD_leftInvSeq
theorem getD_leftInvSeq (ω : List B) (j : ℕ) :
    (lis ω).getD j 1 =
      π (ω.take j)
        * (Option.map (cs.simple) (ω.get? j)).getD 1
        * (π (ω.take j))⁻¹ 
Arguments: {B : Type u_1} {W : Type u_2} [Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (ω : List B) (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 ω))⁻¹