Theorem: FreeProduct.NeWord.of_word
File: Mathlib/GroupTheory/FreeProduct.lean

tactic: suffices : ∃ (i j : _)(w' : NeWord M i j), w'.toWord.toList = w.toList
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
w : Word M
h : w ≠ empty
⊢ ∃ i j w', toWord w' = w

tactic: cases' w with l hnot1 hchain
state_before: case this
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
w : Word M
h : w ≠ empty
⊢ ∃ i j w', (toWord w').toList = w.toList

tactic: induction' l with x l hi
state_before: case this.mk
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l : List ((i : ι) × M i)
hnot1 : ∀ (l_1 : (i : ι) × M i), l_1 ∈ l → l_1.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) l
h : { toList := l, ne_one := hnot1, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', (toWord w').toList = { toList := l, ne_one := hnot1, chain_ne := hchain }.toList

tactic: rcases this with ⟨i, j, w, h⟩
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
w : Word M
h : w ≠ empty
this : ∃ i j w', (toWord w').toList = w.toList
⊢ ∃ i j w', toWord w' = w

tactic: refine' ⟨i, j, w, _⟩
state_before: case intro.intro.intro
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
w✝ : Word M
h✝ : w✝ ≠ empty
i j : ι
w : NeWord M i j
h : (toWord w).toList = w✝.toList
⊢ ∃ i j w', toWord w' = w✝

tactic: ext
state_before: case intro.intro.intro
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
w✝ : Word M
h✝ : w✝ ≠ empty
i j : ι
w : NeWord M i j
h : (toWord w).toList = w✝.toList
⊢ toWord w = w✝

tactic: rw [h]
state_before: case intro.intro.intro.toList.a.a
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
w✝ : Word M
h✝ : w✝ ≠ empty
i j : ι
w : NeWord M i j
h : (toWord w).toList = w✝.toList
n✝ : ℕ
a✝ : (i : ι) × M i
⊢ a✝ ∈ List.get? (toWord w).toList n✝ ↔ a✝ ∈ List.get? w✝.toList n✝

tactic: contradiction
state_before: case this.mk.nil
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l : List ((i : ι) × M i)
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ l → l_1.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l
h✝ : { toList := l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
hnot1 : ∀ (l : (i : ι) × M i), l ∈ [] → l.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) []
h : { toList := [], ne_one := hnot1, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', (toWord w').toList = { toList := [], ne_one := hnot1, chain_ne := hchain }.toList

tactic: rw [List.forall_mem_cons] at hnot1
state_before: case this.mk.cons
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
x : (i : ι) × M i
l : List ((i : ι) × M i)
hi :
  ∀ (hnot1 : ∀ (l_1 : (i : ι) × M i), l_1 ∈ l → l_1.snd ≠ 1) (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) l),
    { toList := l, ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', (toWord w').toList = { toList := l, ne_one := hnot1, chain_ne := hchain }.toList
hnot1 : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: l → l_1.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: l)
h : { toList := x :: l, ne_one := hnot1, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', (toWord w').toList = { toList := x :: l, ne_one := hnot1, chain_ne := hchain }.toList

tactic: cases' l with y l
state_before: case this.mk.cons
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝ } ≠ empty
x : (i : ι) × M i
l : List ((i : ι) × M i)
hi :
  ∀ (hnot1 : ∀ (l_1 : (i : ι) × M i), l_1 ∈ l → l_1.snd ≠ 1) (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) l),
    { toList := l, ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', (toWord w').toList = { toList := l, ne_one := hnot1, chain_ne := hchain }.toList
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ l → x.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: l)
h : { toList := x :: l, ne_one := hnot1✝, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', (toWord w').toList = { toList := x :: l, ne_one := hnot1✝, chain_ne := hchain }.toList

tactic: refine' ⟨x.1, x.1, singleton x.2 hnot1.1, _⟩
state_before: case this.mk.cons.nil
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ l → l_1.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l
h✝ : { toList := l, ne_one := hnot1✝¹, chain_ne := hchain✝ } ≠ empty
x : (i : ι) × M i
hi :
  ∀ (hnot1 : ∀ (l : (i : ι) × M i), l ∈ [] → l.snd ≠ 1) (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) []),
    { toList := [], ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', (toWord w').toList = { toList := [], ne_one := hnot1, chain_ne := hchain }.toList
hnot1✝ : ∀ (l : (i : ι) × M i), l ∈ [x] → l.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ [] → x.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) [x]
h : { toList := [x], ne_one := hnot1✝, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', (toWord w').toList = { toList := [x], ne_one := hnot1✝, chain_ne := hchain }.toList

tactic: simp [toWord]
state_before: case this.mk.cons.nil
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ l → l_1.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l
h✝ : { toList := l, ne_one := hnot1✝¹, chain_ne := hchain✝ } ≠ empty
x : (i : ι) × M i
hi :
  ∀ (hnot1 : ∀ (l : (i : ι) × M i), l ∈ [] → l.snd ≠ 1) (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) []),
    { toList := [], ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', (toWord w').toList = { toList := [], ne_one := hnot1, chain_ne := hchain }.toList
hnot1✝ : ∀ (l : (i : ι) × M i), l ∈ [x] → l.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ [] → x.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) [x]
h : { toList := [x], ne_one := hnot1✝, chain_ne := hchain } ≠ empty
⊢ (toWord (singleton x.snd (_ : x.snd ≠ 1))).toList = { toList := [x], ne_one := hnot1✝, chain_ne := hchain }.toList

tactic: rw [List.chain'_cons] at hchain
state_before: case this.mk.cons.cons
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝ } ≠ empty
x y : (i : ι) × M i
l : List ((i : ι) × M i)
hi :
  ∀ (hnot1 : ∀ (l_1 : (i : ι) × M i), l_1 ∈ y :: l → l_1.snd ≠ 1)
    (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)),
    { toList := y :: l, ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', (toWord w').toList = { toList := y :: l, ne_one := hnot1, chain_ne := hchain }.toList
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: y :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1
hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: y :: l)
h : { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain } ≠ empty
⊢ ∃ i j w', (toWord w').toList = { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain }.toList

tactic: specialize hi hnot1.2 hchain.2 (by rintro ⟨rfl⟩)
state_before: case this.mk.cons.cons
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝¹ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝¹ } ≠ empty
x y : (i : ι) × M i
l : List ((i : ι) × M i)
hi :
  ∀ (hnot1 : ∀ (l_1 : (i : ι) × M i), l_1 ∈ y :: l → l_1.snd ≠ 1)
    (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)),
    { toList := y :: l, ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', (toWord w').toList = { toList := y :: l, ne_one := hnot1, chain_ne := hchain }.toList
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: y :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: y :: l)
hchain : x.fst ≠ y.fst ∧ List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)
h : { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
⊢ ∃ i j w', (toWord w').toList = { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ }.toList

tactic: obtain ⟨i, j, w', hw' : w'.toList = y::l⟩ := hi
state_before: case this.mk.cons.cons
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝¹ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝¹ } ≠ empty
x y : (i : ι) × M i
l : List ((i : ι) × M i)
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: y :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: y :: l)
hchain : x.fst ≠ y.fst ∧ List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)
h : { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
hi :
  ∃ i j w',
    (toWord w').toList =
      { toList := y :: l, ne_one := (_ : ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1),
          chain_ne := (_ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)) }.toList
⊢ ∃ i j w', (toWord w').toList = { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ }.toList

tactic: obtain rfl : y = ⟨i, w'.head⟩ := by simpa [hw'] using w'.toList_head?
state_before: case this.mk.cons.cons.intro.intro.intro
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝¹ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝¹ } ≠ empty
x y : (i : ι) × M i
l : List ((i : ι) × M i)
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: y :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: y :: l)
hchain : x.fst ≠ y.fst ∧ List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)
h : { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
i j : ι
w' : NeWord M i j
hw' : toList w' = y :: l
⊢ ∃ i j w', (toWord w').toList = { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ }.toList

tactic: refine' ⟨x.1, j, append (singleton x.2 hnot1.1) hchain.1 w', _⟩
state_before: case this.mk.cons.cons.intro.intro.intro
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝¹ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝¹ } ≠ empty
x : (i : ι) × M i
l : List ((i : ι) × M i)
i j : ι
w' : NeWord M i j
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: { fst := i, snd := head w' } :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ { fst := i, snd := head w' } :: l → x.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: { fst := i, snd := head w' } :: l)
hchain :
  x.fst ≠ { fst := i, snd := head w' }.fst ∧
    List.Chain' (fun l l' => l.fst ≠ l'.fst) ({ fst := i, snd := head w' } :: l)
h : { toList := x :: { fst := i, snd := head w' } :: l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
hw' : toList w' = { fst := i, snd := head w' } :: l
⊢ ∃ i_1 j_1 w'_1,
    (toWord w'_1).toList =
      { toList := x :: { fst := i, snd := head w' } :: l, ne_one := hnot1✝, chain_ne := hchain✝ }.toList

tactic: rintro ⟨rfl⟩
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝¹ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝¹ } ≠ empty
x y : (i : ι) × M i
l : List ((i : ι) × M i)
hi :
  ∀ (hnot1 : ∀ (l_1 : (i : ι) × M i), l_1 ∈ y :: l → l_1.snd ≠ 1)
    (hchain : List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)),
    { toList := y :: l, ne_one := hnot1, chain_ne := hchain } ≠ empty →
      ∃ i j w', (toWord w').toList = { toList := y :: l, ne_one := hnot1, chain_ne := hchain }.toList
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: y :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: y :: l)
hchain : x.fst ≠ y.fst ∧ List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)
h : { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
⊢ { toList := y :: l, ne_one := (_ : ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1),
      chain_ne := (_ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)) } ≠
    empty

tactic: simpa [hw'] using w'.toList_head?
state_before: ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝¹ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝¹ } ≠ empty
x y : (i : ι) × M i
l : List ((i : ι) × M i)
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: y :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ y :: l → x.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: y :: l)
hchain : x.fst ≠ y.fst ∧ List.Chain' (fun l l' => l.fst ≠ l'.fst) (y :: l)
h : { toList := x :: y :: l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
i j : ι
w' : NeWord M i j
hw' : toList w' = y :: l
⊢ y = { fst := i, snd := head w' }

tactic: simpa [toWord] using hw'
state_before: case this.mk.cons.cons.intro.intro.intro
ι : Type u_1
M : ι → Type u_2
inst✝¹ : (i : ι) → Monoid (M i)
N : Type ?u.593472
inst✝ : Monoid N
l✝ : List ((i : ι) × M i)
hnot1✝¹ : ∀ (l : (i : ι) × M i), l ∈ l✝ → l.snd ≠ 1
hchain✝¹ : List.Chain' (fun l l' => l.fst ≠ l'.fst) l✝
h✝ : { toList := l✝, ne_one := hnot1✝¹, chain_ne := hchain✝¹ } ≠ empty
x : (i : ι) × M i
l : List ((i : ι) × M i)
i j : ι
w' : NeWord M i j
hnot1✝ : ∀ (l_1 : (i : ι) × M i), l_1 ∈ x :: { fst := i, snd := head w' } :: l → l_1.snd ≠ 1
hnot1 : x.snd ≠ 1 ∧ ∀ (x : (i : ι) × M i), x ∈ { fst := i, snd := head w' } :: l → x.snd ≠ 1
hchain✝ : List.Chain' (fun l l' => l.fst ≠ l'.fst) (x :: { fst := i, snd := head w' } :: l)
hchain :
  x.fst ≠ { fst := i, snd := head w' }.fst ∧
    List.Chain' (fun l l' => l.fst ≠ l'.fst) ({ fst := i, snd := head w' } :: l)
h : { toList := x :: { fst := i, snd := head w' } :: l, ne_one := hnot1✝, chain_ne := hchain✝ } ≠ empty
hw' : toList w' = { fst := i, snd := head w' } :: l
⊢ (toWord (append (singleton x.snd (_ : x.snd ≠ 1)) (_ : x.fst ≠ { fst := i, snd := head w' }.fst) w')).toList =
    { toList := x :: { fst := i, snd := head w' } :: l, ne_one := hnot1✝, chain_ne := hchain✝ }.toList