lean/OAI/Computability/MinUncut/Estimates/CodeContinuations.lean

import Mathlib
import OAI.Computability.MinUncut.Graphs.GeneratedGraph

namespace OAI

namespace MinUncut.Costed.Arena
open Turing.ToPartrec

lemma simulate_cons {f fs v u w A B} (hf : Simulates f v u A) (hfs : Simulates fs v w B) :
    Simulates (.cons f fs) v (u.headI::w) (A+B+3) := by
  intro h pc env k hc hv
  cases hc with
  | cons hp hb ht hcf hcfs =>
    let frame₁ := node 0 (read h pc 2) env k
    let h₁ := frame₁::h
    obtain ⟨h₂,out,n,hn,he,ho,tr⟩ := hf h₁ (read h pc 1) env (h.length+1)
      (hcf.extend frame₁) (hv.extend frame₁)
    have hh : Extends h h₂ := (Extends.cons h frame₁).trans he
    have hr (j : Fin 4) : read h₂ (h.length+1) j=frame₁ j := by
      rw [he.read _ (by simp [h₁]),read_new]
    have start : Trace ⟨0,pc,env,k,h⟩ ⟨0,read h pc 1,env,h.length+1,h₁⟩ 1 := by
      apply Trace.one
      simp only [State.tick,ht,ite_true,h₁,frame₁]
    let frame₂ := node 1 u.headI 0 k
    let h₃ := frame₂::h₂
    have hh₃ : Extends h h₃ := hh.trans (Extends.cons h₂ frame₂)
    have next : Trace ⟨1,0,out,h.length+1,h₂⟩ ⟨0,read h pc 2,env,h₂.length+1,h₃⟩ 1 := by
      apply Trace.one
      simp only [State.tick,show (1:ℕ)≠0 by omega,ite_false,ite_true,
        show h.length+1≠0 by omega,hr,frame₁,node_zero,node_one,node_two,node_three,
        ho.head,h₃,frame₂]
    obtain ⟨h₄,out',m,hm,he',ho',tr'⟩ := hfs h₃ (read h pc 2) env (h₂.length+1)
      (hcfs.mono hh₃) (hv.mono hh₃)
    have hr' (j : Fin 4) : read h₄ (h₂.length+1) j=frame₂ j := by
      rw [he'.read _ (by simp [h₃]),read_new]
    let h₅ := node u.headI out' 0 0::h₄
    have finish : Trace ⟨1,0,out',h₂.length+1,h₄⟩ ⟨1,0,h₄.length+1,k,h₅⟩ 1 := by
      apply Trace.one
      simp only [State.tick,show (1:ℕ)≠0 by omega,ite_false,ite_true,
        show h₂.length+1≠0 by omega,hr',frame₂,node_zero,node_one,node_three,h₅]
    refine ⟨h₅,h₄.length+1,1+n+1+m+1,by omega,
      hh₃.trans (he'.trans (Extends.cons h₄ _)),ho'.push _,?_⟩
    exact (((start.trans tr).trans next).trans tr').trans finish

lemma simulate_fixDone {f v u A} (hf : Simulates f v u A) (hz : u.headI=0) :
    Simulates (.fix f) v u.tail (A+2) := by
  intro h pc env k hc hv
  cases hc with
  | fix hp hb ht hcf =>
    let frame := node 3 pc 0 k
    let h₁ := frame::h
    obtain ⟨h₂,out,n,hn,he,ho,tr⟩ := hf h₁ (read h pc 1) env (h.length+1)
      (hcf.extend frame) (hv.extend frame)
    have hh : Extends h h₂ := (Extends.cons h frame).trans he
    have hr (j : Fin 4) : read h₂ (h.length+1) j=frame j := by
      rw [he.read _ (by simp [h₁]),read_new]
    have start : Trace ⟨0,pc,env,k,h⟩ ⟨0,read h pc 1,env,h.length+1,h₁⟩ 1 := by
      apply Trace.one
      simp only [State.tick,ht,ite_true,h₁,frame]
    have finish : Trace ⟨1,0,out,h.length+1,h₂⟩ ⟨1,0,read h₂ out 1,k,h₂⟩ 1 := by
      apply Trace.one
      simp only [State.tick,show (1:ℕ)≠0 by omega,ite_false,ite_true,
        show h.length+1≠0 by omega,hr,frame,node_zero,node_three,ho.head,hz]
    exact ⟨h₂,read h₂ out 1,1+n+1,by omega,hh,ho.tail,(start.trans tr).trans finish⟩

lemma simulate_fixMore {f v u a w A B} (hf : Simulates f v ((a+1)::u) A)
    (hfix : Simulates (.fix f) u w B) : Simulates (.fix f) v w (A+B+2) := by
  intro h pc env k hc hv
  have hc₀ := hc
  cases hc with
  | fix hp hb ht hcf =>
    let frame := node 3 pc 0 k
    let h₁ := frame::h
    obtain ⟨h₂,out,n,hn,he,ho,tr⟩ := hf h₁ (read h pc 1) env (h.length+1)
      (hcf.extend frame) (hv.extend frame)
    have hh : Extends h h₂ := (Extends.cons h frame).trans he
    have hr (j : Fin 4) : read h₂ (h.length+1) j=frame j := by
      rw [he.read _ (by simp [h₁]),read_new]
    have start : Trace ⟨0,pc,env,k,h⟩ ⟨0,read h pc 1,env,h.length+1,h₁⟩ 1 := by
      apply Trace.one
      simp only [State.tick,ht,ite_true,h₁,frame]
    have next : Trace ⟨1,0,out,h.length+1,h₂⟩ ⟨0,pc,read h₂ out 1,k,h₂⟩ 1 := by
      apply Trace.one
      simp only [State.tick,show (1:ℕ)≠0 by omega,ite_false,ite_true,
        show h.length+1≠0 by omega,hr,frame,node_zero,node_one,node_three,ho.head,
        List.headI_cons,show a+1≠0 by omega]
    obtain ⟨h₃,out',m,hm,he',ho',tr'⟩ := hfix h₂ pc (read h₂ out 1) k (hc₀.mono hh) ho.tail
    exact ⟨h₃,out',1+n+1+m,by omega,hh.trans he',ho',((start.trans tr).trans next).trans tr'⟩

lemma Simulates.mono {c v w A B} (h : Simulates c v w A) (hAB : A≤B) : Simulates c v w B := by
  intro heap pc env k hc hv
  obtain ⟨h',out,n,hn,he,ho,tr⟩ := h heap pc env k hc hv
  exact ⟨h',out,n,hn.trans hAB,he,ho,tr⟩

lemma CodeRun.simulates {c v w t} (h : CodeRun c v w t) : Simulates c v w (3*t) := by
  induction h with
  | zero v => exact (simulate_zero v).mono (by omega)
  | succ v => exact (simulate_succ v).mono (by omega)
  | tail v => exact (simulate_tail v).mono (by omega)
  | cons _ _ ih ih' => exact (simulate_cons ih ih').mono (by omega)
  | comp _ _ ih ih' => exact (simulate_comp ih ih').mono (by omega)
  | caseZero hz _ ih => exact (simulate_caseZero hz ih).mono (by omega)
  | caseSucc _ ih => exact (simulate_caseSucc ih).mono (by omega)
  | fixDone _ hz ih => exact (simulate_fixDone ih hz).mono (by omega)
  | fixMore _ _ ih ih' => exact (simulate_fixMore ih ih').mono (by omega)

open Turing.ToPartrec

def listCells : List ℕ → Heap → ℕ × Heap
  | [],h => (0,h)
  | a::v,h =>
    let r := listCells v h
    (r.2.length+1,node a r.1 0 0::r.2)

lemma listCells_spec (v : List ℕ) (h : Heap) :
    Extends h (listCells v h).2 ∧ ListRep (listCells v h).2 (listCells v h).1 v := by
  induction v with
  | nil => exact ⟨Extends.refl h,ListRep.nil⟩
  | cons a v ih =>
    exact ⟨ih.1.trans (Extends.cons _ _),ih.2.push a⟩

lemma listCells_length (v : List ℕ) (h : Heap) : (listCells v h).2.length=v.length+h.length := by
  induction v with
  | nil => simp [listCells]
  | cons a v ih => simp only [listCells,List.length_cons,ih]; omega

def initialState (c : Code) (v : List ℕ) (base : Heap := []) : State :=
  let hc := codeCells c base.length++base
  let r := listCells v hc
  ⟨0,base.length+(codeCells c base.length).length,r.1,0,r.2⟩

lemma initialState_spec (c : Code) (v : List ℕ) (base : Heap) :
    CodeAt (initialState c v base).heap (initialState c v base).pc c ∧
    ListRep (initialState c v base).heap (initialState c v base).env v := by
  exact ⟨(codeCells_spec c base).mono (listCells_spec v _).1,(listCells_spec v _).2⟩

lemma State.tick_halted (pc env k : ℕ) (h : Heap) :
    (State.mk 2 pc env k h).tick=State.mk 2 pc env k h := by
  simp [State.tick]

lemma Trace.pad_halted {s : State} (env : ℕ) (h : Heap) {n B : ℕ}
    (ht : Trace s ⟨2,0,env,0,h⟩ n) (hn : n≤B) : Trace s ⟨2,0,env,0,h⟩ B := by
  have hs : ∀i,State.tick^[i] (State.mk 2 0 env 0 h)=State.mk 2 0 env 0 h := by
    intro i
    induction i with
    | zero => rfl
    | succ i ih => rw [Function.iterate_succ_apply',ih,State.tick_halted]
  have hh := ht.trans (show Trace (State.mk 2 0 env 0 h) _ (B-n) from hs (B-n))
  simpa only [Nat.add_sub_of_le hn] using hh

lemma CodeRun.interpreted {c v w t} (hr : CodeRun c v w t) (base : Heap) {B : ℕ} (hB : t≤B) :
    ∃h out,ListRep h out w ∧
      rawTick^[3*B+1] (initialState c v base).encode=(State.mk 2 0 out 0 h).encode := by
  have hi := initialState_spec c v base
  obtain ⟨h,out,n,hn,he,ho,tr⟩ := CodeRun.simulates hr _ _ _ 0 hi.1 hi.2
  have last : Trace (State.mk 1 0 out 0 h) (State.mk 2 0 out 0 h) 1 := by
    apply Trace.one
    simp [State.tick]
  have tr' := (tr.trans last).pad_halted out h (by omega : n+1≤3*B+1)
  refine ⟨h,out,ho,?_⟩
  have interp (s : State) (i : ℕ) : rawTick^[i] s.encode=(State.tick^[i] s).encode := by
    induction i with
    | zero => rfl
    | succ i ih => rw [Function.iterate_succ_apply',ih,rawTick_encode,Function.iterate_succ_apply']
  rw [interp]
  exact congrArg State.encode tr'

structure OutputState where
  ptr : ℕ
  heap : Heap
  acc : List ℕ

def OutputState.encode (s : OutputState) : List ℕ :=
  [s.ptr,s.heap.length,s.acc.length]++s.acc++2::words s.heap

def OutputState.tick (s : OutputState) : OutputState :=
  if s.ptr=0 then s else ⟨read s.heap s.ptr 1,s.heap,read s.heap s.ptr 0::s.acc⟩

def outRead (j : Fin 4) : Expr :=
  .at (.add (.add (.const (4+j.val)) (.reg 2))
    (.mul (.const 4) (.sub (.reg 1) (.reg 0))))

def outputStep (v : List ℕ) : List ℕ :=
  if v.headI=0 then v else
    [(outRead 1).eval v,(r 1).eval v,(r 2).eval v+1,(outRead 0).eval v]++v.drop 3

noncomputable def outputStepProgram : PolyProgram outputStep := by
  let P := (outRead 1).program.cons ((r 1).program.cons
    ((Expr.add (r 2) (c 1)).program.cons ((outRead 0).program.cons (PolyProgram.drop 3))))
  exact (PolyProgram.branch PolyProgram.head PolyProgram.id P).ofEq (by
    intro v
    rfl)

@[simp] lemma out_encode_reg0 (s : OutputState) : (r 0).eval s.encode=s.ptr := rfl
@[simp] lemma out_encode_reg1 (s : OutputState) : (r 1).eval s.encode=s.heap.length := rfl
@[simp] lemma out_encode_reg2 (s : OutputState) : (r 2).eval s.encode=s.acc.length := rfl

lemma outRead_encode (s : OutputState) (j : Fin 4) (hp : s.ptr≠0) :
    (outRead j).eval s.encode=read s.heap s.ptr j := by
  rw [read_words,ite_eq_right hp]
  simp only [outRead,Expr.eval]
  change (s.encode.drop (4+j.val+s.acc.length+4*(s.heap.length-s.ptr))).headI=_
  rw [show 4+j.val+s.acc.length+4*(s.heap.length-s.ptr)=
    (3+s.acc.length+1)+(4*(s.heap.length-s.ptr)+j.val) by omega,←List.drop_drop]
  have hs : s.encode.drop (3+s.acc.length+1)=words s.heap := by
    have he : ([s.ptr,s.heap.length,s.acc.length]++s.acc++[2]).length=3+s.acc.length+1 := by simp; omega
    have hh : (([s.ptr,s.heap.length,s.acc.length]++s.acc++[2])++words s.heap).drop
        ([s.ptr,s.heap.length,s.acc.length]++s.acc++[2]).length=words s.heap := List.drop_left
    rw [he] at hh
    simpa only [OutputState.encode,List.append_assoc,List.singleton_append] using hh
  rw [hs]

lemma outputStep_encode (s : OutputState) : outputStep s.encode=s.tick.encode := by
  by_cases hp : s.ptr=0
  · simp only [outputStep,OutputState.tick,hp,OutputState.encode,List.cons_append,
      List.nil_append,List.headI_cons,ite_true]
  · simp only [outputStep,OutputState.tick,hp,ite_false]
    change (if s.ptr=0 then _ else _) = _
    rw [ite_eq_right hp,outRead_encode s 1 hp,outRead_encode s 0 hp,out_encode_reg1,out_encode_reg2]
    rfl

lemma output_raw_iter (s : OutputState) (i : ℕ) :
    outputStep^[i] s.encode=(OutputState.tick^[i] s).encode := by
  induction i with
  | zero => rfl
  | succ i ih => rw [Function.iterate_succ_apply',ih,outputStep_encode,Function.iterate_succ_apply']

lemma ListRep.output_iter {h p v} (hv : ListRep h p v) (acc : List ℕ) :
    OutputState.tick^[v.length] ⟨p,h,acc⟩=⟨0,h,v.reverse++acc⟩ := by
  induction hv generalizing acc with
  | nil => rfl
  | @cons p a q v hpos hb ha hq hv ih =>
    rw [List.length_cons,Function.iterate_succ_apply]
    have hs : OutputState.tick ⟨p,h,acc⟩=⟨q,h,a::acc⟩ := by
      simp only [OutputState.tick,show ¬(_=0) from Nat.ne_of_gt hpos,ite_false,ha,hq]
    rw [hs,ih]
    simp only [List.reverse_cons,List.append_assoc,List.singleton_append]

lemma output_null_iter (h : Heap) (acc : List ℕ) (i : ℕ) :
    OutputState.tick^[i] ⟨0,h,acc⟩=⟨0,h,acc⟩ := by
  induction i with
  | zero => rfl
  | succ i ih => rw [Function.iterate_succ_apply',ih]; rfl

lemma ListRep.output_padded {h p v} (hv : ListRep h p v) (acc : List ℕ) {B : ℕ} (hB : v.length≤B) :
    outputStep^[B] (OutputState.mk p h acc).encode=(OutputState.mk 0 h (v.reverse++acc)).encode := by
  rw [output_raw_iter,show B=(B-v.length)+v.length by omega,Function.iterate_add_apply,
    hv.output_iter,output_null_iter]

end MinUncut.Costed.Arena

end OAI