Theorem: Turing.PartrecToTM2.move_ok
File: Mathlib/Computability/TMToPartrec.lean

tactic: induction' L₁ with a L₁ IH generalizing S s
state_before: p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S : K' → List Γ'
h₁ : k₁ ≠ k₂
e : splitAtPred p (S k₁) = (L₁, o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }

tactic: rw [(_ : [].reverseAux _ = _), Function.update_eq_self]
state_before: case nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux [] (S k₂)) }

tactic: swap
state_before: case nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
    { l := some q, var := o, stk := update S k₁ L₂ }

p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ List.reverseAux [] (S k₂) = update S k₁ L₂ k₂

tactic: refine' TransGen.head' rfl _
state_before: case nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
    { l := some q, var := o, stk := update S k₁ L₂ }

tactic: simp
state_before: case nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ ReflTransGen (fun a b => b ∈ TM2.step tr a) (TM2.stepAux (tr (Λ'.move p k₁ k₂ q)) s S)
    { l := some q, var := o, stk := update S k₁ L₂ }

tactic: revert e
state_before: case nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ ReflTransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (S k₁), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (S k₁), stk := update S k₁ (List.tail (S k₁)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (S k₁),
        stk :=
          update (update S k₁ (List.tail (S k₁))) k₂
            (Option.iget (List.head? (S k₁)) :: update S k₁ (List.tail (S k₁)) k₂) })
    { l := some q, var := o, stk := update S k₁ L₂ }

tactic: cases' S k₁ with a Sk <;> intro e
state_before: case nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
⊢ splitAtPred p (S k₁) = ([], o, L₂) →
    ReflTransGen
      (fun a b =>
        (match a with
          | { l := none, var := var, stk := stk } => none
          | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
          some b)
      (bif
          match List.head? (S k₁), true, p with
          | some x, x_1, f => f x
          | none, y, x => y then
        { l := some q, var := List.head? (S k₁), stk := update S k₁ (List.tail (S k₁)) }
      else
        { l := some (Λ'.move p k₁ k₂ q), var := List.head? (S k₁),
          stk :=
            update (update S k₁ (List.tail (S k₁))) k₂
              (Option.iget (List.head? (S k₁)) :: update S k₁ (List.tail (S k₁)) k₂) })
      { l := some q, var := o, stk := update S k₁ L₂ }

tactic: simp only [splitAtPred, Option.elim, List.head?, List.tail_cons, Option.iget_some] at e ⊢
state_before: case nil.cons
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
a : Γ'
Sk : List Γ'
e : splitAtPred p (a :: Sk) = ([], o, L₂)
⊢ ReflTransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a :: Sk), stk := update S k₁ (List.tail (a :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a :: Sk),
        stk :=
          update (update S k₁ (List.tail (a :: Sk))) k₂
            (Option.iget (List.head? (a :: Sk)) :: update S k₁ (List.tail (a :: Sk)) k₂) })
    { l := some q, var := o, stk := update S k₁ L₂ }

tactic: revert e
state_before: case nil.cons
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
a : Γ'
Sk : List Γ'
e :
  (bif p a then ([], some a, Sk)
    else (a :: (splitAtPred p Sk).fst, (splitAtPred p Sk).2.fst, (splitAtPred p Sk).2.snd)) =
    ([], o, L₂)
⊢ ReflTransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif p a then { l := some q, var := some a, stk := update S k₁ Sk }
    else { l := some (Λ'.move p k₁ k₂ q), var := some a, stk := update (update S k₁ Sk) k₂ (a :: update S k₁ Sk k₂) })
    { l := some q, var := o, stk := update S k₁ L₂ }

tactic: cases p a <;> intro e <;>
simp only [cond_false, cond_true, Prod.mk.injEq, true_and, false_and] at e ⊢
state_before: case nil.cons
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
a : Γ'
Sk : List Γ'
⊢ (bif p a then ([], some a, Sk)
      else (a :: (splitAtPred p Sk).fst, (splitAtPred p Sk).2.fst, (splitAtPred p Sk).2.snd)) =
      ([], o, L₂) →
    ReflTransGen
      (fun a b =>
        (match a with
          | { l := none, var := var, stk := stk } => none
          | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
          some b)
      (bif p a then { l := some q, var := some a, stk := update S k₁ Sk }
      else { l := some (Λ'.move p k₁ k₂ q), var := some a, stk := update (update S k₁ Sk) k₂ (a :: update S k₁ Sk k₂) })
      { l := some q, var := o, stk := update S k₁ L₂ }

tactic: rw [Function.update_noteq h₁.symm]
state_before: p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ List.reverseAux [] (S k₂) = update S k₁ L₂ k₂

tactic: rfl
state_before: p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = ([], o, L₂)
⊢ List.reverseAux [] (S k₂) = S k₂

tactic: cases e
state_before: case nil.nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p [] = ([], o, L₂)
⊢ ReflTransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? [], true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? [], stk := update S k₁ (List.tail []) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? [],
        stk := update (update S k₁ (List.tail [])) k₂ (Option.iget (List.head? []) :: update S k₁ (List.tail []) k₂) })
    { l := some q, var := o, stk := update S k₁ L₂ }

tactic: rfl
state_before: case nil.nil.refl
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S✝ k₁) = (L₁, none, [])
⊢ ReflTransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? [], true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? [], stk := update S k₁ (List.tail []) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? [],
        stk := update (update S k₁ (List.tail [])) k₂ (Option.iget (List.head? []) :: update S k₁ (List.tail []) k₂) })
    { l := some q, var := none, stk := update S k₁ [] }

tactic: simp only [e]
state_before: case nil.cons.true
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
a : Γ'
Sk : List Γ'
e : some a = o ∧ Sk = L₂
⊢ ReflTransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    { l := some q, var := some a, stk := update S k₁ Sk } { l := some q, var := o, stk := update S k₁ L₂ }

tactic: rfl
state_before: case nil.cons.true
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁, o, L₂)
s : Option Γ'
S : K' → List Γ'
a : Γ'
Sk : List Γ'
e : some a = o ∧ Sk = L₂
⊢ ReflTransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    { l := some q, var := o, stk := update S k₁ L₂ } { l := some q, var := o, stk := update S k₁ L₂ }

tactic: refine' TransGen.head rfl _
state_before: case cons
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = (a :: L₁, o, L₂)
⊢ Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux (a :: L₁) (S k₂)) }

tactic: simp
state_before: case cons
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = (a :: L₁, o, L₂)
⊢ TransGen (fun a b => b ∈ TM2.step tr a) (TM2.stepAux (tr (Λ'.move p k₁ k₂ q)) s S)
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux (a :: L₁) (S k₂)) }

tactic: cases' e₁ : S k₁ with a' Sk <;> rw [e₁, splitAtPred] at e
state_before: case cons
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
e : splitAtPred p (S k₁) = (a :: L₁, o, L₂)
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (S k₁), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (S k₁), stk := update S k₁ (List.tail (S k₁)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (S k₁),
        stk :=
          update (update S k₁ (List.tail (S k₁))) k₂
            (Option.iget (List.head? (S k₁)) :: update S k₁ (List.tail (S k₁)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

tactic: cases e₂ : p a' <;> simp only [e₂, cond] at e
state_before: case cons.cons
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
a' : Γ'
Sk : List Γ'
e :
  (bif p a' then ([], some a', Sk)
    else
      match splitAtPred p Sk with
      | (l₁, o, l₂) => (a' :: l₁, o, l₂)) =
    (a :: L₁, o, L₂)
e₁ : S k₁ = a' :: Sk
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a' :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a' :: Sk), stk := update S k₁ (List.tail (a' :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a' :: Sk),
        stk :=
          update (update S k₁ (List.tail (a' :: Sk))) k₂
            (Option.iget (List.head? (a' :: Sk)) :: update S k₁ (List.tail (a' :: Sk)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

tactic: swap
state_before: case cons.cons.false
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
a' : Γ'
Sk : List Γ'
e₁ : S k₁ = a' :: Sk
e₂ : p a' = false
e : (a' :: (splitAtPred p Sk).fst, (splitAtPred p Sk).2.fst, (splitAtPred p Sk).2.snd) = (a :: L₁, o, L₂)
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a' :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a' :: Sk), stk := update S k₁ (List.tail (a' :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a' :: Sk),
        stk :=
          update (update S k₁ (List.tail (a' :: Sk))) k₂
            (Option.iget (List.head? (a' :: Sk)) :: update S k₁ (List.tail (a' :: Sk)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

case cons.cons.true
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
a' : Γ'
Sk : List Γ'
e₁ : S k₁ = a' :: Sk
e₂ : p a' = true
e : ([], some a', Sk) = (a :: L₁, o, L₂)
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a' :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a' :: Sk), stk := update S k₁ (List.tail (a' :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a' :: Sk),
        stk :=
          update (update S k₁ (List.tail (a' :: Sk))) k₂
            (Option.iget (List.head? (a' :: Sk)) :: update S k₁ (List.tail (a' :: Sk)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

tactic: rcases e₃ : splitAtPred p Sk with ⟨_, _, _⟩
state_before: case cons.cons.false
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
a' : Γ'
Sk : List Γ'
e₁ : S k₁ = a' :: Sk
e₂ : p a' = false
e : (a' :: (splitAtPred p Sk).fst, (splitAtPred p Sk).2.fst, (splitAtPred p Sk).2.snd) = (a :: L₁, o, L₂)
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a' :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a' :: Sk), stk := update S k₁ (List.tail (a' :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a' :: Sk),
        stk :=
          update (update S k₁ (List.tail (a' :: Sk))) k₂
            (Option.iget (List.head? (a' :: Sk)) :: update S k₁ (List.tail (a' :: Sk)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

tactic: rw [e₃] at e
state_before: case cons.cons.false.mk.mk
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
a' : Γ'
Sk : List Γ'
e₁ : S k₁ = a' :: Sk
e₂ : p a' = false
e : (a' :: (splitAtPred p Sk).fst, (splitAtPred p Sk).2.fst, (splitAtPred p Sk).2.snd) = (a :: L₁, o, L₂)
fst✝¹ : List Γ'
fst✝ : Option Γ'
snd✝ : List Γ'
e₃ : splitAtPred p Sk = (fst✝¹, fst✝, snd✝)
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a' :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a' :: Sk), stk := update S k₁ (List.tail (a' :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a' :: Sk),
        stk :=
          update (update S k₁ (List.tail (a' :: Sk))) k₂
            (Option.iget (List.head? (a' :: Sk)) :: update S k₁ (List.tail (a' :: Sk)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

tactic: cases e
state_before: case cons.cons.false.mk.mk
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
a' : Γ'
Sk : List Γ'
e₁ : S k₁ = a' :: Sk
e₂ : p a' = false
fst✝¹ : List Γ'
fst✝ : Option Γ'
snd✝ : List Γ'
e : (a' :: (fst✝¹, fst✝, snd✝).fst, (fst✝¹, fst✝, snd✝).2.fst, (fst✝¹, fst✝, snd✝).2.snd) = (a :: L₁, o, L₂)
e₃ : splitAtPred p Sk = (fst✝¹, fst✝, snd✝)
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a' :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a' :: Sk), stk := update S k₁ (List.tail (a' :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a' :: Sk),
        stk :=
          update (update S k₁ (List.tail (a' :: Sk))) k₂
            (Option.iget (List.head? (a' :: Sk)) :: update S k₁ (List.tail (a' :: Sk)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

tactic: simp [e₂]
state_before: case cons.cons.false.mk.mk.refl
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
a : Γ'
s : Option Γ'
S : K' → List Γ'
Sk fst✝¹ : List Γ'
fst✝ : Option Γ'
snd✝ : List Γ'
e₃ : splitAtPred p Sk = (fst✝¹, fst✝, snd✝)
e₁ : S k₁ = a :: Sk
e₂ : p a = false
e : splitAtPred p (S✝ k₁) = (L₁, (fst✝¹, fst✝, snd✝).2.fst, (fst✝¹, fst✝, snd✝).2.snd)
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = ((fst✝¹, fst✝, snd✝).fst, (fst✝¹, fst✝, snd✝).2.fst, (fst✝¹, fst✝, snd✝).2.snd) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := (fst✝¹, fst✝, snd✝).2.fst,
          stk := update (update S k₁ (fst✝¹, fst✝, snd✝).2.snd) k₂ (List.reverseAux (fst✝¹, fst✝, snd✝).fst (S k₂)) }
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a :: Sk), stk := update S k₁ (List.tail (a :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a :: Sk),
        stk :=
          update (update S k₁ (List.tail (a :: Sk))) k₂
            (Option.iget (List.head? (a :: Sk)) :: update S k₁ (List.tail (a :: Sk)) k₂) })
    { l := some q, var := (fst✝¹, fst✝, snd✝).2.fst,
      stk := update (update S k₁ (fst✝¹, fst✝, snd✝).2.snd) k₂ (List.reverseAux (fst✝¹, fst✝, snd✝).fst (a :: S k₂)) }

tactic: convert @IH _ (update (update S k₁ Sk) k₂ (a :: S k₂)) _ using 2 <;>
  simp [Function.update_noteq, h₁, h₁.symm, e₃, List.reverseAux]
state_before: case cons.cons.false.mk.mk.refl
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
a : Γ'
s : Option Γ'
S : K' → List Γ'
Sk fst✝¹ : List Γ'
fst✝ : Option Γ'
snd✝ : List Γ'
e₃ : splitAtPred p Sk = (fst✝¹, fst✝, snd✝)
e₁ : S k₁ = a :: Sk
e₂ : p a = false
e : splitAtPred p (S✝ k₁) = (L₁, (fst✝¹, fst✝, snd✝).2.fst, (fst✝¹, fst✝, snd✝).2.snd)
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = ((fst✝¹, fst✝, snd✝).fst, (fst✝¹, fst✝, snd✝).2.fst, (fst✝¹, fst✝, snd✝).2.snd) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := (fst✝¹, fst✝, snd✝).2.fst,
          stk := update (update S k₁ (fst✝¹, fst✝, snd✝).2.snd) k₂ (List.reverseAux (fst✝¹, fst✝, snd✝).fst (S k₂)) }
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    { l := some (Λ'.move p k₁ k₂ q), var := some a,
      stk := update (update S k₁ Sk) k₂ (Option.iget (some a) :: update S k₁ Sk k₂) }
    { l := some q, var := fst✝, stk := update (update S k₁ snd✝) k₂ (List.reverseAux fst✝¹ (a :: S k₂)) }

tactic: simp [Function.update_comm h₁.symm]
state_before: case h.e'_2.h.e'_7
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
a : Γ'
s : Option Γ'
S : K' → List Γ'
Sk fst✝¹ : List Γ'
fst✝ : Option Γ'
snd✝ : List Γ'
e₃ : splitAtPred p Sk = (fst✝¹, fst✝, snd✝)
e₁ : S k₁ = a :: Sk
e₂ : p a = false
e : splitAtPred p (S✝ k₁) = (L₁, (fst✝¹, fst✝, snd✝).2.fst, (fst✝¹, fst✝, snd✝).2.snd)
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = ((fst✝¹, fst✝, snd✝).fst, (fst✝¹, fst✝, snd✝).2.fst, (fst✝¹, fst✝, snd✝).2.snd) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := (fst✝¹, fst✝, snd✝).2.fst,
          stk := update (update S k₁ (fst✝¹, fst✝, snd✝).2.snd) k₂ (List.reverseAux (fst✝¹, fst✝, snd✝).fst (S k₂)) }
⊢ update (update S k₁ snd✝) k₂ (List.reverseAux fst✝¹ (a :: S k₂)) =
    update (update (update (update S k₁ Sk) k₂ (a :: S k₂)) k₁ snd✝) k₂ (List.reverseAux fst✝¹ (a :: S k₂))

tactic: cases e
state_before: case cons.nil
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
e : ([], none, []) = (a :: L₁, o, L₂)
e₁ : S k₁ = []
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? [], true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? [], stk := update S k₁ (List.tail []) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? [],
        stk := update (update S k₁ (List.tail [])) k₂ (Option.iget (List.head? []) :: update S k₁ (List.tail []) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }

tactic: cases e
state_before: case cons.cons.true
p : Γ' → Bool
k₁ k₂ : K'
q : Λ'
s✝ : Option Γ'
L₁✝ : List Γ'
o : Option Γ'
L₂ : List Γ'
S✝ : K' → List Γ'
h₁ : k₁ ≠ k₂
e✝ : splitAtPred p (S✝ k₁) = (L₁✝, o, L₂)
a : Γ'
L₁ : List Γ'
IH :
  ∀ {s : Option Γ'} {S : K' → List Γ'},
    splitAtPred p (S k₁) = (L₁, o, L₂) →
      Reaches₁ (TM2.step tr) { l := some (Λ'.move p k₁ k₂ q), var := s, stk := S }
        { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (S k₂)) }
s : Option Γ'
S : K' → List Γ'
a' : Γ'
Sk : List Γ'
e₁ : S k₁ = a' :: Sk
e₂ : p a' = true
e : ([], some a', Sk) = (a :: L₁, o, L₂)
⊢ TransGen
    (fun a b =>
      (match a with
        | { l := none, var := var, stk := stk } => none
        | { l := some l, var := v, stk := S } => some (TM2.stepAux (tr l) v S)) =
        some b)
    (bif
        match List.head? (a' :: Sk), true, p with
        | some x, x_1, f => f x
        | none, y, x => y then
      { l := some q, var := List.head? (a' :: Sk), stk := update S k₁ (List.tail (a' :: Sk)) }
    else
      { l := some (Λ'.move p k₁ k₂ q), var := List.head? (a' :: Sk),
        stk :=
          update (update S k₁ (List.tail (a' :: Sk))) k₂
            (Option.iget (List.head? (a' :: Sk)) :: update S k₁ (List.tail (a' :: Sk)) k₂) })
    { l := some q, var := o, stk := update (update S k₁ L₂) k₂ (List.reverseAux L₁ (a :: S k₂)) }