import OAI.Computability.WeisfeilerLeman.Interpreter

namespace OAI

universe uK

namespace WLTime.TypedStack.Program
variable {K : Type uK} [DecidableEq K]

def reverseInto (a b : K) : Program K := ofCode (Code.transfer a b false)

theorem reverseInto_exec (a b : K) (hab : a≠b) (s : Stacks K Bool) :
    (reverseInto a b).Exec s (5*(s a).length+1)
      (Function.update (Function.update s a []) b ((s a).reverse++s b)) :=
  ofCode_exec (Code.transfer_exec a b hab false s)

def shift (a b : K) : Program K :=
  ofCode (.seq (.pushDyn b (fun v => (v a).getD false)) (.pop a))

theorem shift_exec (a b : K) (hab : a≠b) (s : Stacks K Bool) :
    (shift a b).Exec s 4
      (Function.update (Function.update s b ((s a).headD false::s b)) a (s a).tail) := by
  apply ofCode_exec
  have he := Code.Exec.seq (Code.Exec.pushDyn s b (fun v => (v a).getD false)) (Code.Exec.pop _ a)
  simpa [Function.update_of_ne hab,tops] using he

end WLTime.TypedStack.Program

namespace WLTime.Universal
open TypedStack UnaryPrograms Reg

def shiftPair (p : List Bool × List Bool) := (p.1.tail,p.1.headD false::p.2)

theorem shiftPair_prefix (xs ys zs : List Bool) :
    shiftPair^[xs.length] (xs++ys,zs)=(ys,xs.reverse++zs) := by
  induction xs generalizing zs with
  | nil => rfl
  | cons x xs ih =>
    rw [List.length_cons,Function.iterate_succ_apply]
    change shiftPair^[xs.length] (xs++ys,x::zs)=_
    rw [ih,List.reverse_cons,List.append_assoc]
    rfl

def takeDescription : Program Reg :=
  Program.seq (Program.repeatN index (Program.shift search temp)) (Program.reverseInto temp tab)

theorem takeDescription_exec (xs ys : List Bool) (s : Stacks Reg Bool)
    (hs : s search=xs++ys) (hi : s index=numeral xs.length)
    (ht : s temp=[]) (hb : s tab=[]) :
    ∃t≤24*xs.length+4,takeDescription.Exec s t
      (Function.update (Function.update s search ys) tab xs) := by
  let enc (p : List Bool × List Bool) := Function.update (Function.update s search p.1) temp p.2
  have hc (p) : (Program.shift search temp).Exec (enc p) 4 (enc (shiftPair p)) := by
    have he := Program.shift_exec search temp (by decide) (enc p)
    convert he using 1
    funext r; cases r <;> simp [enc,shiftPair]
  have hi' : enc (xs++ys,[]) index=numeral xs.length := by simp [enc,hi]
  obtain ⟨t,htime,he⟩ := Program.repeat_lift index (Program.shift search temp) shiftPair enc 4 xs.length
    (fun p => ⟨4,le_rfl,hc p⟩) (xs++ys,[]) hi'
  rw [shiftPair_prefix] at he
  have hin : enc (xs++ys,[])=s := by
    funext r; cases r <;> simp [enc,hs,ht]
  rw [hin] at he
  have hr := Program.reverseInto_exec temp tab (by decide) (enc (ys,xs.reverse++[]))
  have hout : Function.update (Function.update (enc (ys,xs.reverse++[])) temp []) tab
      (((enc (ys,xs.reverse++[])) temp).reverse++enc (ys,xs.reverse++[]) tab)=
      Function.update (Function.update s search ys) tab xs := by
    funext r; cases r <;> simp [enc,hb,ht]
  rw [hout] at hr
  have hf := Program.seq_exec he hr
  refine ⟨_,?_,hf⟩
  simp only [enc,Function.update_self,List.append_nil,List.length_reverse]
  omega

end WLTime.Universal

namespace WLTime.Universal
open TypedStack UnaryPrograms Reg

def bitValue : Bool → ℕ | false => 1 | true => 2

@[simp] theorem fields_append (xs ys : List ℕ) : fields (xs++ys)=fields xs++fields ys :=
  List.flatMap_append

def tapeBody : Program Reg :=
  Program.seq (Program.push right false) <|
  Program.seq (Program.push right true) <|
  Program.seq (Program.branch (UnaryPrograms.isTrue temp) (Program.push right true) Program.skip) <|
  Program.seq (Program.pop temp) (Program.push base true)

def tapeLoop : Program Reg := Program.loop (Code.nonempty temp) tapeBody

theorem tapeBody_exec (s : Stacks Reg Bool) (b : Bool) (xs : List Bool) (hs : s temp=b::xs) :
    ∃t≤11,tapeBody.Exec s t
      (Function.update (Function.update (Function.update s right (tile (bitValue b)++s right))
        temp xs) base (true::s base)) := by
  let a := Function.update s right (false::s right)
  let c := Function.update a right (true::a right)
  have h1 := Program.push_exec right false s
  have h2 := Program.push_exec right true a
  cases b with
  | false =>
    have hb := Program.branch_false (p:=Program.push right true) (test:=UnaryPrograms.isTrue temp)
      (by simp [UnaryPrograms.isTrue,tops,c,a,hs]) (Program.skip_exec c)
    have h3 := Program.pop_exec temp c
    have h4 := Program.push_exec base true (Function.update c temp (c temp).tail)
    have he := Program.seq_exec h1 (Program.seq_exec h2 (Program.seq_exec hb (Program.seq_exec h3 h4)))
    refine ⟨10,by omega,?_⟩
    convert he using 1 <;> try rfl
    funext r; cases r <;> simp [c,a,tile,bitValue,numeral,hs]
  | true =>
    have hb := Program.branch_true (q:=Program.skip) (test:=UnaryPrograms.isTrue temp)
      (by simp [UnaryPrograms.isTrue,tops,c,a,hs]) (Program.push_exec right true c)
    let d := Function.update c right (true::c right)
    have h3 := Program.pop_exec temp d
    have h4 := Program.push_exec base true (Function.update d temp (d temp).tail)
    have he := Program.seq_exec h1 (Program.seq_exec h2 (Program.seq_exec hb (Program.seq_exec h3 h4)))
    refine ⟨11,by omega,?_⟩
    convert he using 1 <;> try rfl
    funext r; cases r <;> simp [d,c,a,tile,bitValue,numeral,hs]

theorem tapeLoop_exec (xs : List Bool) (s : Stacks Reg Bool) (hs : s temp=xs) :
    ∃t≤12*xs.length+1,tapeLoop.Exec s t
      (Function.update (Function.update (Function.update s temp []) right
        (fields (xs.reverse.map bitValue)++s right)) base (numeral xs.length++s base)) := by
  induction xs generalizing s with
  | nil =>
    have he := Program.loop_false (p:=tapeBody) (test:=Code.nonempty temp) (s:=s)
      (by simp [Code.nonempty,tops,hs])
    refine ⟨1,by simp,?_⟩
    convert he using 1 <;> try rfl
    funext r; cases r <;> simp [hs,fields,numeral]
  | cons b xs ih =>
    let a := Function.update (Function.update (Function.update s right (tile (bitValue b)++s right))
      temp xs) base (true::s base)
    obtain ⟨t,ht,hb⟩ := tapeBody_exec s b xs hs
    obtain ⟨u,hu,hr⟩ := ih a (by simp [a])
    have he := Program.loop_true (test:=Code.nonempty temp)
      (by simp [Code.nonempty,tops,hs]) hb hr
    refine ⟨t+u+1,by simp only [List.length_cons]; omega,?_⟩
    convert he using 1 <;> try rfl
    funext r; cases r <;> simp [a,List.reverse_cons,List.map_append,List.append_assoc,tile]
    rw [numeral_add]
    simp only [numeral,List.replicate_one,List.append_assoc,List.singleton_append]

def inputPrep : Program Reg :=
  Program.seq (Program.copy input search) <|
  Program.seq (Program.reverseInto input temp) tapeLoop

def inputStore (w : List Bool) : Stacks Reg Bool := fun r => if r=input then w else []

def prepared (w : List Bool) : Stacks Reg Bool
  | .search => w
  | .base => numeral w.length
  | .right => fields (w.map bitValue)
  | _ => []

theorem inputPrep_exec (w : List Bool) :
    ∃t≤29*w.length+4,inputPrep.Exec (inputStore w) t (prepared w) := by
  let a := Function.update (inputStore w) search w
  let b := Function.update (Function.update a input []) temp w.reverse
  have h1 : (Program.copy input search).Exec (inputStore w) (12*w.length+2) a := by
    simpa [a,inputStore] using Program.copy_exec input search (by decide) (inputStore w)
  have h2 : (Program.reverseInto input temp).Exec a (5*w.length+1) b := by
    simpa [b,a,inputStore] using Program.reverseInto_exec input temp (by decide) a
  obtain ⟨t,ht,h3⟩ := tapeLoop_exec w.reverse b (by simp [b])
  have hout : Function.update (Function.update (Function.update b temp []) right
      (fields (w.reverse.reverse.map bitValue)++b right)) base (numeral w.reverse.length++b base)=prepared w := by
    funext r; cases r <;> simp [b,a,inputStore,prepared]
  rw [hout] at h3
  have he := Program.seq_exec h1 (Program.seq_exec h2 h3)
  refine ⟨_,?_,he⟩
  simp only [List.length_reverse] at ht
  omega

end WLTime.Universal

namespace WLTime.Universal
open TypedStack UnaryPrograms Reg

def initialConfig (M : OneTape) (w : List Bool) : Config M :=
  (⟨0,by have := M.states_ge; omega⟩,⟨[],w.map M.toTM.symbol⟩)

@[simp] theorem symbol_val (M : OneTape) (b : Bool) : (M.toTM.symbol b).val=bitValue b := by
  cases b <;> rfl

@[simp] theorem map_symbols_val (M : OneTape) (w : List Bool) :
    (w.map M.toTM.symbol).map Fin.val=w.map bitValue := by
  simp only [List.map_map,Function.comp_def,symbol_val]

def parseProgram : Program Reg :=
  Program.seq (Program.read search index) <|
  Program.seq takeDescription <|
  Program.seq (Program.clear search) <|
  Program.seq (Program.clear index) <|
  Program.seq (skipField tab) (Program.read tab alpha)

def initProgram : Program Reg := Program.seq inputPrep parseProgram

theorem parseProgram_exec (M : OneTape) (z : List Bool) :
    ∃ t ≤ 32*(Diagonal.description M).length+3*z.length+3*M.states+5*M.symbols+15,
      parseProgram.Exec (prepared (Diagonal.designation M++z)) t
        (encode M (Diagonal.designation M++z).length (initialConfig M (Diagonal.designation M++z))) := by
  let ds := Diagonal.description M
  let w := Diagonal.designation M++z
  let a := Function.update (Function.update (prepared w) search (ds++z)) index (numeral ds.length)
  let b := Function.update (Function.update a search z) tab ds
  let c := Function.update b search []
  let d := Function.update c index []
  let e := Function.update d tab (Diagonal.unary M.symbols++Diagonal.tableBits (Diagonal.raw M).table)
  have h1 : (Program.read search index).Exec (prepared w) (5*ds.length+3) a := by
    simpa [a,prepared,w,Diagonal.designation,unary_tile,List.append_assoc,ds]
      using Program.read_exec search index (by decide) (prepared w)
  obtain ⟨t2,ht2,h2⟩ := takeDescription_exec ds z a (by simp [a]) (by simp [a])
    (by simp [a,prepared]) (by simp [a,prepared])
  change takeDescription.Exec a t2 b at h2
  have h3 : (Program.clear search).Exec b (3*z.length+1) c := by
    simpa [c,b] using Program.clear_exec search b
  have h4 : (Program.clear index).Exec c (3*ds.length+1) d := by
    simpa [d,c,b,a] using Program.clear_exec index c
  have h5 : (skipField tab).Exec d (3*M.states+3) e := by
    simpa [e,d,c,b,ds,Diagonal.description,Diagonal.Raw.bits,Diagonal.raw,
      unary_tile,List.append_assoc] using skipField_exec tab d
  have h6 : (Program.read tab alpha).Exec e (5*M.symbols+3)
      (Function.update (Function.update e tab (Diagonal.tableBits (Diagonal.raw M).table)) alpha
        (numeral M.symbols)) := by
    simpa [e,d,c,b,a,prepared,unary_tile] using Program.read_exec tab alpha (by decide) e
  have hout : Function.update (Function.update e tab (Diagonal.tableBits (Diagonal.raw M).table)) alpha
      (numeral M.symbols)=encode M w.length (initialConfig M w) := by
    funext r; cases r <;> simp [e,d,c,b,a,prepared,encode,store,initialConfig,haltFlag,numeral]
    exact congrArg fields (map_symbols_val M w).symm
  rw [hout] at h6
  have he := Program.seq_exec h1 (Program.seq_exec h2 (Program.seq_exec h3
    (Program.seq_exec h4 (Program.seq_exec h5 h6))))
  refine ⟨_,?_,he⟩
  dsimp only [ds] at ht2 ⊢
  omega

theorem initProgram_exec (M : OneTape) (z : List Bool) :
    ∃ t ≤ 64*(Diagonal.designation M++z).length+3*M.states+5*M.symbols+19,
      initProgram.Exec (inputStore (Diagonal.designation M++z)) t
        (encode M (Diagonal.designation M++z).length (initialConfig M (Diagonal.designation M++z))) := by
  obtain ⟨t,ht,h1⟩ := inputPrep_exec (Diagonal.designation M++z)
  obtain ⟨u,hu,h2⟩ := parseProgram_exec M z
  refine ⟨t+u,?_,Program.seq_exec h1 h2⟩
  have hd : (Diagonal.description M).length ≤ (Diagonal.designation M++z).length := by
    simp only [Diagonal.designation,List.length_append]
    omega
  have hz : z.length ≤ (Diagonal.designation M++z).length := by simp
  omega

end WLTime.Universal

namespace WLTime.Universal
open OneTape

def Relative (M : OneTape) (C : M.Config ℤ) (c : Config M) : Prop :=
  c.1=C.state ∧ ∀ z,TapePair.contents (zeroSymbol M) c.2 z=C.tape (C.head+z)

theorem initial_relative (M : OneTape) (w : List Bool) :
    Relative M (M.initial w) (initialConfig M w) := by
  refine ⟨rfl,?_⟩
  intro z
  simp only [TapePair.contents,initialConfig,OneTape.initial,zero_add]
  change (if z<0 then ([] : List (Fin M.symbols)).getD (-z-1).toNat (zeroSymbol M)
    else (w.map M.toTM.symbol).getD z.toNat (zeroSymbol M)) =
    if 0≤z ∧ z.toNat<w.length then M.toTM.symbol (w.getD z.toNat false) else zeroSymbol M
  dsimp only [OneTape.toTM] at *
  by_cases hz : z<0
  · have hn : ¬(0≤z ∧ z.toNat<w.length) := by omega
    rw [ite_eq_left hz,ite_eq_right hn,List.getD_nil]
  · rw [ite_eq_right hz]
    have hz' : 0≤z := by omega
    by_cases hb : z.toNat<w.length
    · rw [ite_eq_left ⟨hz',hb⟩,List.getD_eq_getElem _ _ (by simpa only [List.length_map] using hb)]
      rw [List.getElem_map,List.getD_eq_getElem _ _ hb]
    · rw [ite_eq_right (by omega),List.getD_eq_default _ _ (by simp only [List.length_map]; omega)]

theorem next_relative (M : OneTape) (C : M.Config ℤ) (c : Config M) (h : Relative M C c) :
    Relative M (M.step lineShift C) (next M c) := by
  classical
  have ho : c.2.right.headD (zeroSymbol M)=C.tape C.head := by
    simpa only [TapePair.contents_zero,add_zero] using h.2 0
  by_cases hh : C.state.val=1 ∨ C.state.val=2
  · rw [M.step_halted lineShift C hh]
    constructor
    · simp only [next,nextState,h.1,hh,ite_true]
    · simpa only [next,nextTape,h.1,hh,ite_true] using h.2
  · constructor
    · simp only [next,nextState,h.1,hh,ite_false,ho,OneTape.step,OneTape.action]
    · intro z
      simp only [next,nextTape,h.1,hh,ite_false,ho,TapePair.contents_moveWrite]
      rw [h.2]
      simp only [OneTape.step,OneTape.action,hh,ite_false,moveAt_line,Function.update_apply]
      have he : C.head+(M.transition C.state (C.tape C.head)).2.2.displacement+z=C.head ↔
          z+(M.transition C.state (C.tape C.head)).2.2.displacement=0 := by omega
      rw [he]
      rw [show C.head+(z+(M.transition C.state (C.tape C.head)).2.2.displacement)=
        C.head+(M.transition C.state (C.tape C.head)).2.2.displacement+z by omega]
      by_cases hp : z+(M.transition C.state (C.tape C.head)).2.2.displacement=0 <;>
        simp only [hp,ite_true,ite_false]

theorem iterate_relative (M : OneTape) (w : List Bool) (t : ℕ) :
    Relative M (M.run lineShift (M.initial w) t) ((next M)^[t] (initialConfig M w)) := by
  induction t with
  | zero => exact initial_relative M w
  | succ t ih =>
    simp only [OneTape.run,Function.iterate_succ_apply'] at *
    exact next_relative M _ _ ih

theorem simulated_state (M : OneTape) (w : List Bool) (t : ℕ) :
    ((next M)^[t] (initialConfig M w)).1.val=(M.toTM.run w t).state.val := by
  have h := (iterate_relative M w t).1
  have ht := congrArg (fun C : M.toTM.Config => C.state.val) (M.embed_run w t)
  exact congrArg Fin.val h |>.trans ht

end WLTime.Universal

namespace WLTime.TypedStack.Program
variable {K : Type uK} [DecidableEq K]

def inputStacks (k : K) (w : List Bool) : Stacks K Bool := fun j => if j=k then w else []

abbrev FinalState (p : Program K) := p.code.State ⊕ Unit

def finalTransition (p : Program K) (answer : Tops K Bool → Bool) :
    FinalState p → Tops (Fin p.scratch ⊕ K) Bool → Command (Fin p.scratch ⊕ K) Bool (FinalState p)
  | .inl q,v => Command.redirect Sum.inl (.inr ()) (p.code.transition q v)
  | .inr _,v => .halt (answer (v ∘ Sum.inr))

def machine (p : Program K) (k : K) (answer : Tops K Bool → Bool) :
    Machine (Fin p.scratch ⊕ K) Bool (FinalState p) where
  inputStack := .inr k
  inputLetter := id
  initial := .inl p.code.entry
  transition := finalTransition p answer

theorem machine_initial (p : Program K) (k : K) (answer : Tops K Bool → Bool) (w : List Bool) :
    (p.machine k answer).initialConfig w=⟨.inr (.inl p.code.entry),p.ambient (inputStacks k w)⟩ := by
  dsimp only [Machine.initialConfig,machine]
  congr 1
  funext j
  cases j with
  | inl i => simp [ambient]
  | inr i => simp [ambient,inputStacks]

theorem machine_run (p : Program K) (k : K) (answer : Tops K Bool → Bool) (w : List Bool)
    {t out} (h : p.Exec (inputStacks k w) t out) :
    (p.machine k answer).run w (t+1)=⟨.inl (answer (tops out)),p.ambient out⟩ := by
  have he := (Code.exec_finite h).plug Sum.inl (.inr ()) (fun _ _ => rfl)
    (Execution.halt (tr:=finalTransition p answer) (q:=.inr ()) (s:=p.ambient out) rfl)
  rw [Machine.run,machine_initial]
  exact Execution.iterate (p.machine k answer) he

variable [Fintype K]

theorem oneTape_correct (p : Program K) (k : K) (answer : Tops K Bool → Bool) (w : List Bool)
    {t out} (h : p.Exec (inputStacks k w) t out) :
    (p.machine k answer).compile.oneTape.toTM.halts w ∧
    (p.machine k answer).compile.oneTape.toTM.time w ≤
      8*(p.scratch+Fintype.card K+1)*(w.length+t+2)^2 ∧
    ((p.machine k answer).compile.oneTape.toTM.accepts w ↔ answer (tops out)=true) := by
  have hrun := congrArg Config.state (p.machine_run k answer w h)
  have he := (p.machine k answer).oneTape_correct w (t+1) (answer (tops out)) hrun
  simpa only [Fintype.card_sum,Fintype.card_fin,show w.length+(t+1)+1=w.length+t+2 by omega] using he

end WLTime.TypedStack.Program

namespace WLTime.Universal
open TypedStack Reg

def boundedProgram (s : ℕ) : Program Reg := Program.seq initProgram (steps s)
def answer (v : Tops Reg Bool) : Bool := v halt != some false

noncomputable def machine (s : ℕ) : OneTape := ((boundedProgram s).machine input answer).compile.oneTape

@[simp] theorem haltFlag_answer (q : ℕ) : ((haltFlag q).head? != some false)=decide (q≠1) := by
  by_cases h1 : q=1
  · simp [haltFlag,h1]
  · by_cases h2 : q=2 <;> simp [haltFlag,h1,h2]

theorem boundedProgram_exec (s : ℕ) (M : OneTape) (z : List Bool)
    (hm : 0 < (Diagonal.designation M++z).length) :
    ∃ t ≤ 64*(Diagonal.designation M++z).length+3*M.states+5*M.symbols+19+
        (stepBound M+18*s)*(Diagonal.designation M++z).length^s,
      (boundedProgram s).Exec (inputStore (Diagonal.designation M++z)) t
        (encode M (Diagonal.designation M++z).length
          ((next M)^[(Diagonal.designation M++z).length^s] (initialConfig M (Diagonal.designation M++z)))) := by
  obtain ⟨t,ht,h1⟩ := initProgram_exec M z
  obtain ⟨u,hu,h2⟩ := steps_exec M (Diagonal.designation M++z).length hm s (initialConfig M (Diagonal.designation M++z))
  exact ⟨t+u,by omega,Program.seq_exec h1 h2⟩

def timeBound (s : ℕ) (M : OneTape) (m : ℕ) : ℕ :=
  8*((boundedProgram s).scratch+Fintype.card Reg+1)*
    (65*m+3*M.states+5*M.symbols+21+(stepBound M+18*s)*m^s)^2

theorem machine_correct (s : ℕ) (M : OneTape) (z : List Bool)
    (hm : 0 < (Diagonal.designation M++z).length) :
    (machine s).toTM.halts (Diagonal.designation M++z) ∧
    (machine s).toTM.time (Diagonal.designation M++z) ≤ timeBound s M (Diagonal.designation M++z).length ∧
    ((machine s).toTM.accepts (Diagonal.designation M++z) ↔
      ¬∃ t ≤ (Diagonal.designation M++z).length^s,
        (M.toTM.run (Diagonal.designation M++z) t).state.val=1) := by
  let w := Diagonal.designation M++z
  obtain ⟨t,ht,he⟩ := boundedProgram_exec s M z hm
  have hc := (boundedProgram s).oneTape_correct input answer w he
  change (machine s).toTM.halts w ∧ (machine s).toTM.time w ≤ timeBound s M w.length ∧
    ((machine s).toTM.accepts w ↔ ¬∃ t ≤ w.length^s, (M.toTM.run w t).state.val=1)
  refine ⟨hc.1,?_,?_⟩
  · apply hc.2.1.trans
    apply Nat.mul_le_mul_left
    apply Nat.pow_le_pow_left
    dsimp only [w]
    omega
  · change ((boundedProgram s).machine input answer).compile.oneTape.toTM.accepts w ↔ _
    rw [hc.2.2]
    simp only [answer,tops,encode,store,haltFlag_answer,decide_eq_true_eq]
    rw [simulated_state]
    constructor
    · intro h ⟨u,hu,hacc⟩
      exact h (by rw [M.toTM.run_frozen w (Or.inl hacc) hu]; exact hacc)
    · intro h hacc
      exact h ⟨w.length^s,le_rfl,hacc⟩

end WLTime.Universal

end OAI