case zero'
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.zero' k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.zero' (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case succ
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.succ k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.succ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case tail
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
c : Code
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal c k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal c (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
induction c generalizing k v s
case succ
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.succ k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.succ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case tail
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case zero'
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.zero' k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.zero' (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case succ
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.succ k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.succ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case tail
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case zero' => refine' ⟨_, ⟨s, rfl⟩, TransGen.single _⟩; simp
case tail
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case succ
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.succ k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.succ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case tail
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case succ => refine' ⟨_, ⟨none, rfl⟩, head_main_ok.trans succ_ok⟩
case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case tail
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case tail =>
  let o : Option Γ' := List.casesOn v none fun _ _ => some Γ'.cons
  refine' ⟨_, ⟨o, rfl⟩, _⟩; convert clear_ok _ using 2; simp; rfl; swap
  refine' splitAtPred_eq _ _ (trNat v.headI) _ _ (trNat_natEnd _) _
  cases v <;> simp
case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case cons
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case
  cons f fs IHf _ =>
  obtain ⟨c, h₁, h₂⟩ := IHf (Cont.cons₁ fs v k) v none
  refine' ⟨c, h₁, TransGen.head rfl <| (move_ok (by decide) (splitAtPred_false _)).trans _⟩
  simp [stepNormal]
  refine' (copy_ok _ none [] (trList v).reverse _ _).trans _
  convert h₂ using 2
  simp [List.reverseAux_eq, trContStack]
case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case comp
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case case
a✝¹ a✝ : Code
a_ih✝¹ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝¹ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝¹ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case a✝¹ a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case a✝¹ a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
        b₂

case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case comp f _ _ IHg => exact IHg (Cont.comp f k) v s
no goals
case fix
a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case fix f IH => apply IH
k : Cont
v : List ℕ
s : Option Γ'
⊢ { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList (0 :: v)) [] [] (trContStack k) } ∈
    TM2.step tr { l := some (trNormal Code.zero' (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.zero' k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.zero' (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
refine' ⟨_, ⟨s, rfl⟩, TransGen.single _⟩
no goals
k : Cont
v : List ℕ
s : Option Γ'
⊢ { l := some (Λ'.ret (trCont k)), var := s, stk := elim (trList (0 :: v)) [] [] (trContStack k) } ∈
    TM2.step tr { l := some (trNormal Code.zero' (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
simp
no goals
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.succ k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.succ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
refine' ⟨_, ⟨none, rfl⟩, head_main_ok.trans succ_ok⟩
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
let o : Option Γ' := List.casesOn v none fun _ _ => some Γ'.cons
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ Reaches₁ (TM2.step tr)
    { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
    { l := some (Λ'.ret (trCont k)), var := o, stk := elim (trList (List.tail v)) [] [] (trContStack k) }
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ ∃ b₂,
    TrCfg (stepNormal Code.tail k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
refine' ⟨_, ⟨o, rfl⟩, _⟩
case h.e'_4.h.e'_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ elim (trList (List.tail v)) [] [] (trContStack k) = update (elim (trList v) [] [] (trContStack k)) main ?convert_7

case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, ?convert_7)
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ Reaches₁ (TM2.step tr)
    { l := some (trNormal Code.tail (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) }
    { l := some (Λ'.ret (trCont k)), var := o, stk := elim (trList (List.tail v)) [] [] (trContStack k) }
convert clear_ok _ using 2
case h.e'_4.h.e'_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ elim (trList (List.tail v)) [] [] (trContStack k) = elim ?convert_7 [] [] (trContStack k)

case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, ?convert_7)
case h.e'_4.h.e'_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ elim (trList (List.tail v)) [] [] (trContStack k) = update (elim (trList v) [] [] (trContStack k)) main ?convert_7

case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, ?convert_7)
simp
case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, trList (List.tail v))
case h.e'_4.h.e'_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ elim (trList (List.tail v)) [] [] (trContStack k) = elim ?convert_7 [] [] (trContStack k)

case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_7
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, ?convert_7)
rfl
case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, trList (List.tail v))

case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'
case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'

case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, trList (List.tail v))
swap
case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ Option.elim' (elim (trList v) [] [] (trContStack k) main = trNat (List.headI v) ∧ trList (List.tail v) = [])
    (fun a =>
      natEnd a = true ∧ elim (trList v) [] [] (trContStack k) main = trNat (List.headI v) ++ a :: trList (List.tail v))
    o
case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ splitAtPred natEnd (elim (trList v) [] [] (trContStack k) main) = (?convert_5, o, trList (List.tail v))

case convert_5
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ List Γ'
refine' splitAtPred_eq _ _ (trNat v.headI) _ _ (trNat_natEnd _) _
no goals
case convert_9
k : Cont
v : List ℕ
s : Option Γ'
o : Option Γ' := List.casesOn v none fun x x => some Γ'.cons
⊢ Option.elim' (elim (trList v) [] [] (trContStack k) main = trNat (List.headI v) ∧ trList (List.tail v) = [])
    (fun a =>
      natEnd a = true ∧ elim (trList v) [] [] (trContStack k) main = trNat (List.headI v) ++ a :: trList (List.tail v))
    o
cases v <;> simp
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons f fs) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons f fs) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons f fs) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons f fs) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
obtain ⟨c, h₁, h₂⟩ := IHf (Cont.cons₁ fs v k) v none
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ TransGen (fun a b => b ∈ TM2.step tr a)
    { l := some (Λ'.copy (trNormal f (Cont'.cons₁ fs (trCont k)))), var := none,
      stk :=
        update
          (update
            (update (elim (trList v) [] [] (trContStack k)) stack
              ((fun s => Option.iget ((fun x => some Γ'.consₗ) s)) s :: elim (trList v) [] [] (trContStack k) stack))
            main [])
          rev
          (List.reverseAux
            (update (elim (trList v) [] [] (trContStack k)) stack
              ((fun s => Option.iget ((fun x => some Γ'.consₗ) s)) s :: elim (trList v) [] [] (trContStack k) stack)
              main)
            (update (elim (trList v) [] [] (trContStack k)) stack
              ((fun s => Option.iget ((fun x => some Γ'.consₗ) s)) s :: elim (trList v) [] [] (trContStack k) stack)
              rev)) }
    c
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.cons f fs) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.cons f fs) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
refine' ⟨c, h₁, TransGen.head rfl <| (move_ok (by decide) (splitAtPred_false _)).trans _⟩
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ 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 (Λ'.copy (trNormal f (Cont'.cons₁ fs (trCont k)))), var := none,
      stk := elim [] (List.reverseAux (trList v) []) [] (Option.iget (some Γ'.consₗ) :: trContStack k) }
    c
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ TransGen (fun a b => b ∈ TM2.step tr a)
    { l := some (Λ'.copy (trNormal f (Cont'.cons₁ fs (trCont k)))), var := none,
      stk :=
        update
          (update
            (update (elim (trList v) [] [] (trContStack k)) stack
              ((fun s => Option.iget ((fun x => some Γ'.consₗ) s)) s :: elim (trList v) [] [] (trContStack k) stack))
            main [])
          rev
          (List.reverseAux
            (update (elim (trList v) [] [] (trContStack k)) stack
              ((fun s => Option.iget ((fun x => some Γ'.consₗ) s)) s :: elim (trList v) [] [] (trContStack k) stack)
              main)
            (update (elim (trList v) [] [] (trContStack k)) stack
              ((fun s => Option.iget ((fun x => some Γ'.consₗ) s)) s :: elim (trList v) [] [] (trContStack k) stack)
              rev)) }
    c
simp [stepNormal]
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ TransGen (fun a b => b ∈ TM2.step tr a)
    { l := some (trNormal f (Cont'.cons₁ fs (trCont k))), var := none,
      stk :=
        elim (List.reverseAux (List.reverse (trList v)) []) [] []
          (List.reverseAux (List.reverse (trList v)) (Option.iget (some Γ'.consₗ) :: trContStack k)) }
    c
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ 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 (Λ'.copy (trNormal f (Cont'.cons₁ fs (trCont k)))), var := none,
      stk := elim [] (List.reverseAux (trList v) []) [] (Option.iget (some Γ'.consₗ) :: trContStack k) }
    c
refine' (copy_ok _ none [] (trList v).reverse _ _).trans _
case h.e'_1.h.e'_7
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ elim (List.reverseAux (List.reverse (trList v)) []) [] []
      (List.reverseAux (List.reverse (trList v)) (Option.iget (some Γ'.consₗ) :: trContStack k)) =
    elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k))
case intro.intro
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ TransGen (fun a b => b ∈ TM2.step tr a)
    { l := some (trNormal f (Cont'.cons₁ fs (trCont k))), var := none,
      stk :=
        elim (List.reverseAux (List.reverse (trList v)) []) [] []
          (List.reverseAux (List.reverse (trList v)) (Option.iget (some Γ'.consₗ) :: trContStack k)) }
    c
convert h₂ using 2
no goals
case h.e'_1.h.e'_7
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ elim (List.reverseAux (List.reverse (trList v)) []) [] []
      (List.reverseAux (List.reverse (trList v)) (Option.iget (some Γ'.consₗ) :: trContStack k)) =
    elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k))
simp [List.reverseAux_eq, trContStack]
no goals
f fs : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal fs k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal fs (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
c : Cfg'
h₁ : TrCfg (stepNormal f (Cont.cons₁ fs v k) v) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont (Cont.cons₁ fs v k))), var := none,
      stk := elim (trList v) [] [] (trContStack (Cont.cons₁ fs v k)) }
    c
⊢ main ≠ rev
decide
no goals
f a✝ : Code
a_ih✝ :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal a✝ k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal a✝ (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.comp f a✝) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.comp f a✝) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
exact IHg (Cont.comp f k) v s
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg
        ((fun k v =>
            Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v))
          k v)
        b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.case f g) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
rw [stepNormal]
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg
        ((fun k v =>
            Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v))
          k v)
        b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
simp only
case intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
    (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
      (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
      (List.headI v))
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
obtain ⟨s', h⟩ := pred_ok _ _ s v _ _
case intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
⊢ Reaches₁ (TM2.step tr)
      { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
      (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
        (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
        (List.headI v)) →
    ∃ b₂,
      TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v)) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
    (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
      (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
      (List.headI v))
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
revert h
case intro.zero
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
    (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
      (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
      Nat.zero)
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) Nat.zero) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂

case intro.succ
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
n : ℕ
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
    (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
      (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
      (Nat.succ n))
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (Nat.succ n)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
⊢ Reaches₁ (TM2.step tr)
      { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
      (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
        (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
        (List.headI v)) →
    ∃ b₂,
      TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (List.headI v)) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
cases' v.headI with n <;> intro h
case intro.zero.intro.intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
    (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
      (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
      Nat.zero)
c : Cfg'
h₁ : TrCfg (stepNormal f k ?m.575677) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont k)), var := s', stk := elim (trList ?m.575677) [] [] (trContStack k) } c
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) Nat.zero) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case intro.zero
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
    (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
      (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
      Nat.zero)
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) Nat.zero) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
obtain ⟨c, h₁, h₂⟩ := IHf k _ s'
no goals
case intro.zero.intro.intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred ?m.575544 ?m.575545), var := s, stk := elim (trList v) [] ?m.575546 ?m.575547 }
    (Nat.rec { l := some ?m.575544, var := s', stk := elim (trList (List.tail v)) [] ?m.575546 ?m.575547 }
      (fun n x => { l := some ?m.575545, var := s', stk := elim (trList (n :: List.tail v)) [] ?m.575546 ?m.575547 })
      Nat.zero)
c : Cfg'
h₁ : TrCfg (stepNormal f k ?m.575677) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal f (trCont k)), var := s', stk := elim (trList ?m.575677) [] [] (trContStack k) } c
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) Nat.zero) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
exact ⟨_, h₁, h.trans h₂⟩
case intro.succ.intro.intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
n : ℕ
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred (trNormal f (trCont k)) (trNormal g (trCont k))), var := s,
      stk := elim (trList v) [] [] (trContStack k) }
    (Nat.rec { l := some (trNormal f (trCont k)), var := s', stk := elim (trList (List.tail v)) [] [] (trContStack k) }
      (fun n x =>
        { l := some (trNormal g (trCont k)), var := s', stk := elim (trList (n :: List.tail v)) [] [] (trContStack k) })
      (Nat.succ n))
c : Cfg'
h₁ : TrCfg (stepNormal g k ?m.575801) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal g (trCont k)), var := s', stk := elim (trList ?m.575801) [] [] (trContStack k) } c
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (Nat.succ n)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
case intro.succ
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
n : ℕ
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred (trNormal f (trCont k)) (trNormal g (trCont k))), var := s,
      stk := elim (trList v) [] [] (trContStack k) }
    (Nat.rec { l := some (trNormal f (trCont k)), var := s', stk := elim (trList (List.tail v)) [] [] (trContStack k) }
      (fun n x =>
        { l := some (trNormal g (trCont k)), var := s', stk := elim (trList (n :: List.tail v)) [] [] (trContStack k) })
      (Nat.succ n))
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (Nat.succ n)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
obtain ⟨c, h₁, h₂⟩ := IHg k _ s'
no goals
case intro.succ.intro.intro
f g : Code
IHf :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
IHg :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal g k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal g (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s s' : Option Γ'
n : ℕ
h :
  Reaches₁ (TM2.step tr)
    { l := some (Λ'.pred (trNormal f (trCont k)) (trNormal g (trCont k))), var := s,
      stk := elim (trList v) [] [] (trContStack k) }
    (Nat.rec { l := some (trNormal f (trCont k)), var := s', stk := elim (trList (List.tail v)) [] [] (trContStack k) }
      (fun n x =>
        { l := some (trNormal g (trCont k)), var := s', stk := elim (trList (n :: List.tail v)) [] [] (trContStack k) })
      (Nat.succ n))
c : Cfg'
h₁ : TrCfg (stepNormal g k ?m.575801) c
h₂ :
  Reaches₁ (TM2.step tr)
    { l := some (trNormal g (trCont k)), var := s', stk := elim (trList ?m.575801) [] [] (trContStack k) } c
⊢ ∃ b₂,
    TrCfg (Nat.rec (stepNormal f k (List.tail v)) (fun y x => stepNormal g k (y :: List.tail v)) (Nat.succ n)) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.case f g) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
exact ⟨_, h₁, h.trans h₂⟩
no goals
f : Code
IH :
  ∀ (k : Cont) (v : List ℕ) (s : Option Γ'),
    ∃ b₂,
      TrCfg (stepNormal f k v) b₂ ∧
        Reaches₁ (TM2.step tr)
          { l := some (trNormal f (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
k : Cont
v : List ℕ
s : Option Γ'
⊢ ∃ b₂,
    TrCfg (stepNormal (Code.fix f) k v) b₂ ∧
      Reaches₁ (TM2.step tr)
        { l := some (trNormal (Code.fix f) (trCont k)), var := s, stk := elim (trList v) [] [] (trContStack k) } b₂
apply IH