import OAI.ModelTheory.Choiceless.Counters

namespace OAI

namespace CPTSeparation.TableMachine

open CounterLang

inductive Index where
 | t | y | a | x | z
 deriving DecidableEq

instance : Fintype Index := ⟨{.t,.y,.a,.x,.z}, by intro i; cases i <;> simp⟩

inductive Reg where
 | size | width
 | idx : Index → Reg
 | rem : Index → Reg
 | addr | prod | tmp | cmp
 deriving DecidableEq, Fintype

abbrev CState (V : Type) := CounterLang.State Reg (Bool × V)

abbrev Prog (V : Type) := CounterLang.Program Reg (Bool × V)

lemma tableInput_length {N} (S : OrderedQuery.Data N) : (tableInput S).length = 8*(N*N) := by
 simp [tableInput]

lemma tableInput_lookup {N} (S : OrderedQuery.Data N) (r : Symbol) (a b : Fin N) :
 (tableInput S)[((OrderedQuery.symbolIndex r).val*N+a.val)*N+b.val]? =
   some (bitLetter (S.rel r a b)) := by
 have hi : ((OrderedQuery.symbolIndex r).val*N+a.val)*N+b.val =
     (OrderedQuery.cellIndex r a b).val := by
   simp [OrderedQuery.cellIndex,finProdFinEquiv]
   ring
 rw [hi]
 simp [tableInput,OrderedQuery.tableBits,OrderedQuery.cellValue_index]

def readCell {V} (k : ℕ) (i j : Index) (f : V → Option Letter → V) : Prog V :=
 .seq (.atom (.zero .addr))
 (.seq (repeatAdd .size .addr (by decide) k)
 (.seq (.atom (.add (.idx i) .addr (by simp)))
 (.seq (multiply .addr .size .prod .tmp (by decide) (by decide))
 (.seq (.atom (.add (.idx j) .prod (by simp)))
 (.seq (.atom (.lookup .prod (fun c a => (c.1,f c.2 a))))
 (.seq (.atom (.zero .addr)) (.atom (.zero .prod))))))))

lemma readCell_runs {V} (s : CState V) (k : ℕ) (i j : Index) (f : V → Option Letter → V)
   (haddr : s.nums .addr = 0) (hprod : s.nums .prod = 0) (htmp : s.nums .tmp = 0) :
 Runs (readCell k i j f) s
   {s with ctl := (false,f s.ctl.2 s.input[((k*s.nums .size+s.nums (.idx i))*s.nums .size+s.nums (.idx j))]?)}
   (16*k*(s.nums .size)^2+16*s.nums (.idx i)*s.nums .size +
     6*k*s.nums .size+8*k+16*s.nums .size+6*s.nums (.idx i)+16*s.nums (.idx j)+10*s.input.length+101) := by
 let s₁ := (Atom.zero .addr).eval s
 let s₂ : CState V := {s₁ with nums := Function.update s₁.nums .addr (s₁.nums .addr+k*s₁.nums .size)}
 let s₃ := (Atom.add (.idx i) .addr (by simp)).eval s₂
 let s₄ : CState V := {s₃ with ctl := (false,s₃.ctl.2), nums := Function.update (Function.update s₃.nums .prod (s₃.nums .addr*s₃.nums .size)) .tmp 0}
 let s₅ := (Atom.add (.idx j) .prod (by simp)).eval s₄
 let s₆ := (Atom.lookup .prod (fun c a => (c.1,f c.2 a))).eval s₅
 let s₇ := (Atom.zero .addr).eval s₆
 let s₈ := (Atom.zero .prod).eval s₇
 have hm := multiply_runs .addr .size .prod .tmp (by decide) (by decide) (by decide) (by decide) (by decide) s₃
 have h := (Runs.atom (.zero .addr) s).seq
   ((repeatAdd_runs .size .addr (by decide) k s₁).seq
   ((Runs.atom (.add (.idx i) .addr (by simp)) s₂).seq
   (hm.seq ((Runs.atom (.add (.idx j) .prod (by simp)) s₄).seq
   ((Runs.atom (.lookup .prod (fun c a => (c.1,f c.2 a))) s₅).seq
   ((Runs.atom (.zero .addr) s₆).seq (Runs.atom (.zero .prod) s₇)))))))
 have he : s₈ = {s with ctl := (false,f s.ctl.2 s.input[((k*s.nums .size+s.nums (.idx i))*s.nums .size+s.nums (.idx j))]?)} := by
   apply CounterLang.State.ext
   · simp [s₈,s₇,s₆,s₅,s₄,s₃,s₂,s₁,Atom.eval,Function.update,Nat.add_comm]
   · funext r; cases r <;> simp [s₈,s₇,s₆,s₅,s₄,s₃,s₂,s₁,Atom.eval,Function.update,haddr,hprod,htmp]
   · rfl
   · rfl
 change Runs (readCell k i j f) s s₈ _ at h
 rw [he] at h
 apply h.mono
 simp only [s₇,s₆,s₅,s₄,s₃,s₂,s₁,Atom.eval,Atom.cost]
 simp [Function.update,haddr,hprod,htmp]
 ; nlinarith

end CPTSeparation.TableMachine

namespace CPTSeparation.Bounded

section

open CounterLang TableMachine

inductive Program (V : Type) where
 | load (f : V → V)
 | emit (f : V → Letter)
 | cell (r : Symbol) (i j : Index) (f : V → Bool → V)
 | equal (i j : Index) (f : V → Bool → V)
 | seq (a b : Program V)
 | loop (i : Index) (body : Program V)

variable {V : Type}

def isOne (a : Option Letter) : Bool := a == some (some 1)

def Program.WF : Program V → Finset Index → Prop
 | .load _,_ => True
 | .emit _,_ => True
 | .cell _ _ _ _,_ => True
 | .equal _ _ _,_ => True
 | .seq a b,S => a.WF S ∧ b.WF S
 | .loop i b,S => i ∉ S ∧ b.WF (insert i S)

def Program.eval (N : ℕ) (table : List Letter) :
    Program V → (Index → ℕ) → V × List Letter → V × List Letter
 | .load f,_,s => (f s.1,s.2)
 | .emit f,_,s => (s.1,f s.1::s.2)
 | .cell r i j f,e,s => (f s.1 (isOne table[((OrderedQuery.symbolIndex r).val*N+e i)*N+e j]?),s.2)
 | .equal i j f,e,s => (f s.1 (e i == e j),s.2)
 | .seq a b,e,s => b.eval N table e (a.eval N table e s)
 | .loop i b,e,s => (List.range N).foldl (fun s k => b.eval N table (Function.update e i k) s) s

def equalCode (i j : Index) (f : V → Bool → V) : Prog V :=
 .seq (CounterLang.compare (.idx i) (.idx j) .addr .prod (by simp) (by simp) f)
   (.seq (.atom (.zero .addr)) (.atom (.zero .prod)))

def Program.compile : Program V → Prog V
 | .load f => .atom (.load (fun c => (false,f c.2)))
 | .emit f => .seq (.atom (.emit (fun c => f c.2))) (.atom (.load (fun c => (false,c.2))))
 | .cell r i j f => readCell (OrderedQuery.symbolIndex r).val i j (fun v a => f v (isOne a))
 | .equal i j f => equalCode i j f
 | .seq a b => .seq a.compile b.compile
 | .loop i b => .seq (.atom (.load (fun c => (false,c.2))))
   (forRange .size (.idx i) (.rem i) (by simp) b.compile)

def Program.time (N L : ℕ) : Program V → ℕ
 | .load _ => 1
 | .emit _ => 3
 | .cell _ _ _ _ => 1000*(N+1)^2+10*L
 | .equal _ _ _ => 100*(N+1)
 | .seq a b => 1+(a.time N L+b.time N L)
 | .loop _ b => (b.time N L+13)*N+22

def env (s : CState V) : Index → ℕ := fun i => s.nums (.idx i)

def result (s : CState V) (v : V × List Letter) : CState V :=
 {s with ctl := (false,v.1), output := v.2}

def Ready (S : Finset Index) (N : ℕ) (s : CState V) : Prop :=
 s.nums .size = N ∧ s.nums .addr = 0 ∧ s.nums .prod = 0 ∧ s.nums .tmp = 0 ∧
 (∀ i, s.nums (.idx i) ≤ N) ∧ (∀ i ∉ S, s.nums (.idx i) = 0 ∧ s.nums (.rem i) = 0)

@[simp] lemma ready_result {S N} (s : CState V) (v) : Ready S N (result s v) ↔ Ready S N s := Iff.rfl

@[simp] lemma env_result (s : CState V) (v) : env (result s v) = env s := rfl

@[simp] lemma result_result (s : CState V) (v w) : result (result s v) w = result s w := rfl

lemma ready_index {S N} (s : CState V) (hs : Ready S N s) (i : Index) (k : ℕ) (hk : k≤N) :
 Ready (insert i S) N (indexState (.idx i) (.rem i) N k s) := by
 rcases hs with ⟨hN,ha,hp,ht,hidx,hr⟩
 refine ⟨?_,?_,?_,?_,?_,?_⟩
 · simpa [indexState,Function.update] using hN
 · simpa [indexState,Function.update] using ha
 · simpa [indexState,Function.update] using hp
 · simpa [indexState,Function.update] using ht
 · intro j
   by_cases hji : j=i
   · subst j; simpa [indexState,Function.update] using hk
   · simpa [indexState,Function.update,hji] using hidx j
 · intro j hj
   have hh : j≠i ∧ j∉S := by simpa using hj
   simpa [indexState,Function.update,hh.1] using hr j hh.2

@[simp] lemma env_index (s : CState V) (i : Index) (N k) :
 env (indexState (.idx i) (.rem i) N k s) = Function.update (env s) i k := by
 funext j; by_cases h : j=i <;> simp [env,indexState,Function.update,h]

lemma equalCode_runs (i j : Index) (f : V → Bool → V) (s : CState V)
    (ha : s.nums .addr=0) (hp : s.nums .prod=0) (N : ℕ)
    (hi : s.nums (.idx i)≤N) (hj : s.nums (.idx j)≤N) :
 Runs (equalCode i j f) s (result s (f s.ctl.2 (s.nums (.idx i)==s.nums (.idx j)),s.output)) (100*(N+1)) := by
 let s₁ : CState V := {s with ctl := (false,f s.ctl.2 (decide (s.nums (.idx i)=s.nums (.idx j)))), nums := Function.update (Function.update s.nums .addr (s.nums (.idx i)-s.nums (.idx j))) .prod (s.nums (.idx j)-s.nums (.idx i))}
 let s₂ := (Atom.zero .addr).eval s₁
 have hc := compare_runs (.idx i) (.idx j) .addr .prod (by simp) (by simp) (by simp) (by decide) f s
 change Runs _ s s₁ _ at hc
 have h := hc.seq ((Runs.atom (.zero .addr) s₁).seq (Runs.atom (.zero .prod) s₂))
 have he : (Atom.zero .prod).eval s₂ = result s (f s.ctl.2 (s.nums (.idx i)==s.nums (.idx j)),s.output) := by
   apply CounterLang.State.ext
   · rfl
   · funext r; cases r <;> simp [s₂,s₁,Atom.eval,result,Function.update,ha,hp]
   · rfl
   · rfl
 rw [he] at h
 apply h.mono
 simp [s₂,s₁,Atom.cost,Atom.eval,Function.update,ha,hp]
 omega

lemma cell_runs (r : Symbol) (i j : Index) (f : V → Bool → V)
    (s : CState V) {S N} (hs : Ready S N s) :
 Runs (Program.compile (.cell r i j f)) s
   (result s ((Program.cell r i j f).eval N s.input (env s) (s.ctl.2,s.output)))
   (1000*(N+1)^2+10*s.input.length) := by
 have h := readCell_runs s (OrderedQuery.symbolIndex r).val i j (fun v a => f v (isOne a)) hs.2.1 hs.2.2.1 hs.2.2.2.1
 have he : s.nums .size=N := hs.1
 simp only [he] at h
 apply h.mono
 have hk : (OrderedQuery.symbolIndex r).val ≤ 8 := (OrderedQuery.symbolIndex r).isLt.le
 have hi := hs.2.2.2.2.1 i
 have hj := hs.2.2.2.2.1 j
 calc
  _ ≤ 16*8*N^2+16*N*N+6*8*N+8*8+16*N+6*N+16*N+10*s.input.length+101 := by gcongr
  _ ≤ _ := by nlinarith

lemma compile_runs (p : Program V) (S : Finset Index) (hw : p.WF S)
    (N : ℕ) (s : CState V) (hs : Ready S N s) :
 Runs p.compile s (result s (p.eval N s.input (env s) (s.ctl.2,s.output)))
   (p.time N s.input.length) := by
 induction p generalizing S s with
 | load f => exact Runs.atom (.load (fun c => (false,f c.2))) s
 | emit f =>
   exact (Runs.atom (.emit (fun c => f c.2)) s).seq
     (Runs.atom (.load (fun c => (false,c.2))) ((Atom.emit (fun c => f c.2)).eval s))
 | cell r i j f => exact cell_runs r i j f s hs
 | equal i j f => exact equalCode_runs i j f s hs.2.1 hs.2.2.1 N (hs.2.2.2.2.1 i) (hs.2.2.2.2.1 j)
 | seq a b iha ihb =>
   have ha := iha S hw.1 s hs
   have hb := ihb S hw.2 (result s (a.eval N s.input (env s) (s.ctl.2,s.output))) hs
   exact ha.seq hb
 | loop i b ih =>
   let e := env s
   let step := fun v k => b.eval N s.input (Function.update e i k) v
   let pref := fun k => (List.range k).foldl step (s.ctl.2,s.output)
   let st := fun k => result s (pref k)
   have hstep (k : ℕ) : pref (k+1) = step (pref k) k := by simp [pref,List.range_succ,step]
   have hbody (k : ℕ) (hk : k<N) :
       Runs b.compile (indexState (.idx i) (.rem i) N k (st k))
         (flag (indexState (.idx i) (.rem i) N k (st (k+1))) false) (b.time N s.input.length) := by
     have hr : Ready (insert i S) N (indexState (.idx i) (.rem i) N k (st k)) :=
       ready_index (st k) hs i k hk.le
     have h := ih (insert i S) hw.2 (indexState (.idx i) (.rem i) N k (st k)) hr
     rw [env_index] at h
     change Runs _ _ (result (indexState (.idx i) (.rem i) N k (st k)) (step (pref k) k)) _ at h
     rw [← hstep k] at h
     exact h
   have hi := hs.2.2.2.2.2 i hw.1
   have h := forRange_runs TableMachine.Reg.size (.idx i) (.rem i) (by simp) (by simp)
     b.compile st N (b.time N s.input.length)
     (by simpa [st,result] using hs.1)
     (by simpa [st,result] using hi.1) (by simpa [st,result] using hi.2)
     (by simpa [st,result] using hi.1) (by simpa [st,result] using hi.2)
     rfl hbody
   have hin : Runs (.atom (.load (fun c : Bool × V => (false,c.2)))) s (st 0) 1 := by
     simpa [st,pref,result,Atom.eval,Atom.cost] using Runs.atom (.load (fun c : Bool × V => (false,c.2))) s
   have total := hin.seq h
   convert total using 1 <;> first | rfl | (simp only [Program.time]; omega)

end

open CounterLang TableMachine

variable {V : Type}

abbrev Relation := Symbol → ℕ → ℕ → Bool

def readTable (N : ℕ) (w : List Letter) : Relation := fun r a b =>
 isOne w[((OrderedQuery.symbolIndex r).val*N+a)*N+b]?

def Program.interpret (N : ℕ) (rel : Relation) :
    Program V → (Index → ℕ) → V × List Letter → V × List Letter
 | .load f,_,s => (f s.1,s.2)
 | .emit f,_,s => (s.1,f s.1::s.2)
 | .cell r i j f,e,s => (f s.1 (rel r (e i) (e j)),s.2)
 | .equal i j f,e,s => (f s.1 (e i == e j),s.2)
 | .seq a b,e,s => b.interpret N rel e (a.interpret N rel e s)
 | .loop i b,e,s => (List.range N).foldl (fun s k => b.interpret N rel (Function.update e i k) s) s

lemma Program.eval_interpret (p : Program V) (N : ℕ) (w : List Letter) (e) (s) :
 p.eval N w e s = p.interpret N (readTable N w) e s := by
 induction p generalizing e s with
 | load _ => rfl
 | emit _ => rfl
 | cell _ _ _ _ => rfl
 | equal _ _ _ => rfl
 | seq a b iha ihb => simp only [Program.eval,Program.interpret,iha,ihb]
 | loop i b ih =>
   simp only [Program.eval,Program.interpret]
   congr 1
   funext s k
   exact ih _ _

lemma readTable_input {N} (S : OrderedQuery.Data N) (r : Symbol) (a b : Fin N) :
 readTable N (tableInput S) r a b = S.rel r a b := by
 rw [readTable,tableInput_lookup]
 cases h : S.rel r a b <;> decide +revert

lemma fold_emits {α : Type} (ls : List α) (step : V × List Letter → α → V × List Letter)
    (v : V) (chunk : α → List Letter)
    (h : ∀ a ∈ ls, ∀ out, step (v,out) a = (v,(chunk a).reverse++out)) (out) :
 ls.foldl step (v,out) = (v,(ls.flatMap chunk).reverse++out) := by
 induction ls generalizing out with
 | nil => rfl
 | cons a ls ih =>
   rw [List.foldl_cons,h a (by simp),ih (by intro b hb; exact h b (by simp [hb]))]
   simp [List.reverse_append,List.append_assoc]

lemma loop_emits (N : ℕ) (rel : Relation) (body : Program V) (i : Index)
    (e : Index → ℕ) (v : V) (chunk : ℕ → List Letter)
    (h : ∀ k<N, ∀ out, body.interpret N rel (Function.update e i k) (v,out) = (v,(chunk k).reverse++out))
    (out) :
 (Program.loop i body).interpret N rel e (v,out) =
   (v,((List.range N).flatMap chunk).reverse++out) := by
 exact fold_emits _ _ v chunk (by intro k hk; exact h k (List.mem_range.mp hk)) out

lemma Program.time_polynomial (p : Program V) :
 ∃ q : Polynomial ℕ, ∀ N, p.time N (8*(N*N)) = q.eval N := by
 induction p with
 | load f => exact ⟨1,by simp [Program.time]⟩
 | emit f => exact ⟨3,by simp [Program.time]⟩
 | cell r i j f => exact ⟨1000*(Polynomial.X+1)^2+80*Polynomial.X^2,by intro N; simp [Program.time]; ring⟩
 | equal i j f => exact ⟨100*(Polynomial.X+1),by simp [Program.time]⟩
 | seq a b iha ihb =>
   obtain ⟨p,hp⟩ := iha
   obtain ⟨q,hq⟩ := ihb
   exact ⟨1+(p+q),by intro N; simp [Program.time,hp,hq]⟩
 | loop i b ih =>
   obtain ⟨p,hp⟩ := ih
   exact ⟨(p+13)*Polynomial.X+22,by intro N; simp [Program.time,hp]⟩

end CPTSeparation.Bounded

end OAI