import OAI.ModelTheory.Choiceless.Stack

namespace OAI

namespace CPTSeparation.GaussMachine

open StackLang StackLang.Macros SerialGaussian

inductive Reg where
 | mat | back | scan | piv | pivBack | width | output
 deriving DecidableEq

instance : Fintype Reg where
 elems := {.mat, .back, .scan, .piv, .pivBack, .width, .output}
 complete := by intro k; cases k <;> simp

structure Control where
  pivot : Scalar := 0
  factor : Scalar := 0
  answer : Bool := true
 deriving DecidableEq, Fintype

abbrev Local := Option Scalar × Control

abbrev Prog := SProgram Reg Letter Local

structure Data where
  mat : List Letter := []
  back : List Letter := []
  scan : List Letter := []
  piv : List Letter := []
  pivBack : List Letter := []
  width : List Letter := []
  output : List Letter := []
 deriving DecidableEq

def Data.tapes (d : Data) : Reg → List Letter
 | .mat => d.mat
 | .back => d.back
 | .scan => d.scan
 | .piv => d.piv
 | .pivBack => d.pivBack
 | .width => d.width
 | .output => d.output

@[simp] lemma tapes_mat (d : Data) (xs : List Letter) : Function.update d.tapes .mat xs = ({d with mat := xs}).tapes := by funext k; cases k <;> simp [Data.tapes,Function.update]

@[simp] lemma tapes_back (d : Data) (xs : List Letter) : Function.update d.tapes .back xs = ({d with back := xs}).tapes := by funext k; cases k <;> simp [Data.tapes,Function.update]

@[simp] lemma tapes_scan (d : Data) (xs : List Letter) : Function.update d.tapes .scan xs = ({d with scan := xs}).tapes := by funext k; cases k <;> simp [Data.tapes,Function.update]

@[simp] lemma tapes_piv (d : Data) (xs : List Letter) : Function.update d.tapes .piv xs = ({d with piv := xs}).tapes := by funext k; cases k <;> simp [Data.tapes,Function.update]

@[simp] lemma tapes_pivBack (d : Data) (xs : List Letter) : Function.update d.tapes .pivBack xs = ({d with pivBack := xs}).tapes := by funext k; cases k <;> simp [Data.tapes,Function.update]

@[simp] lemma tapes_width (d : Data) (xs : List Letter) : Function.update d.tapes .width xs = ({d with width := xs}).tapes := by funext k; cases k <;> simp [Data.tapes,Function.update]

@[simp] lemma tapes_output (d : Data) (xs : List Letter) : Function.update d.tapes .output xs = ({d with output := xs}).tapes := by funext k; cases k <;> simp [Data.tapes,Function.update]

def st (c : Control) (buf : Option Letter) (d : Data) : SStore Reg Letter Local := state (none,c) buf d.tapes

def _root_.OAI.CPTSeparation.SerialGaussian.Row.entries {n} (r : SerialGaussian.Row n) : List Scalar := r.coeff ++ [r.rhs]

@[simp] lemma entries_length {n} (r : SerialGaussian.Row n) : r.entries.length = n+1 := by simp [SerialGaussian.Row.entries,r.length_eq]

lemma payload_cons {n} (r : SerialGaussian.Row n) (rs) :
 payload (r::rs) = r.entries.map some ++ none::payload rs := by
 simp [payload,SerialGaussian.Row.entries,List.map_append,List.append_assoc]

lemma entries_head_tail {n} (r : SerialGaussian.Row (n+1)) :
 r.entries = r.head :: r.tail.entries := by
 rcases r with ⟨coeff,hl,rhs⟩
 cases coeff with
 | nil => simp at hl
 | cons a coeff => rfl

def scanBody : Prog :=
 .seq (.atom (.pop .scan (fun c a => (none,(none,{c.2.2 with factor := (a.bind id).getD 0}))) .done))
 (.seq (.cond (fun c => c.2.2.pivot == 0 && c.2.2.factor != 0)
    (.seq (.atom (.load (fun c => (c.1,(none,{c.2.2 with pivot := c.2.2.factor}))) .done))
      (moveRow .scan .pivBack (fun _ a => a)))
    (skipRow .scan))
  (.atom (.peek .scan (fun c a => (a,(none,{c.2.2 with factor := 0}))) .done)))

def scanLoop : Prog := .loop (fun c => c.1.isSome) scanBody

def scanMatrix : Prog := .seq (peek .scan) scanLoop

lemma scanBody_skip {n} (c : Control) (buf : Option Letter) (d : Data)
    (r : SerialGaussian.Row (n+1)) (rs : List (SerialGaussian.Row (n+1)))
    (h : c.pivot ≠ 0 ∨ r.head = 0) :
 Runs scanBody (st c buf {d with scan := payload (r::rs)})
   (st {c with factor := 0} (payload rs).head? {d with scan := payload rs})
   (2*(n+1)+10) := by
 let c' : Control := {c with factor := r.head}
 have hp : Runs (.atom (.pop .scan (fun (c : Option Letter × Local) a =>
       (none,(none,{c.2.2 with factor := (a.bind id).getD 0}))) .done))
     (st c buf {d with scan := payload (r::rs)})
     (st c' none {d with scan := r.tail.entries.map some ++ none::payload rs}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,payload_cons,entries_head_tail,c',Data.tapes]
 have hs := skipRow_runs (σ := Local) Reg.scan (none,c') none d.tapes
   r.tail.entries (payload rs)
 have hs' : Runs (skipRow Reg.scan)
      (st c' none {d with scan := r.tail.entries.map some ++ none::payload rs})
      (st c' none {d with scan := payload rs}) (2*(n+1)+5) := by
   simpa [st] using hs
 have hc := Runs.cond_false (a := .seq
    (.atom (.load (fun c : Option Letter × Local =>
      (c.1,(none,{c.2.2 with pivot := c.2.2.factor}))) .done))
    (moveRow Reg.scan Reg.pivBack (fun (_ : Local) a => a)))
    (f := fun c : Option Letter × Local => c.2.2.pivot == 0 && c.2.2.factor != 0)
    (s := st c' none {d with scan := r.tail.entries.map some ++ none::payload rs})
    (by rcases h with h | h <;> simp_all [st,state,c']) hs'
 have hf : Runs (.atom (.peek .scan (fun (c : Option Letter × Local) a =>
       (a,(none,{c.2.2 with factor := 0}))) .done))
     (st c' none {d with scan := payload rs})
     (st {c with factor := 0} (payload rs).head? {d with scan := payload rs}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,c',Data.tapes]
 convert hp.seq (hc.seq hf) using 1 <;> first | rfl | omega

def ctrl (p : Scalar) (a : Bool) : Control := ⟨p,0,a⟩

lemma payload_head {n} (r : SerialGaussian.Row (n+1)) (rs) :
 (payload (r::rs)).head? = some (some r.head) := by
 rw [payload_cons,entries_head_tail]
 rfl

lemma scanLoop_nonzero {n} (p : Scalar) (hp : p ≠ 0) (a : Bool) (d : Data)
    (rs : List (SerialGaussian.Row (n+1))) :
 Runs scanLoop (st (ctrl p a) (payload rs).head? {d with scan := payload rs})
   (st (ctrl p a) none {d with scan := []}) ((2*(n+1)+13)*rs.length+1) := by
 induction rs with
 | nil => exact Runs.loop_false rfl
 | cons r rs ih =>
   have hb := scanBody_skip (ctrl p a) (payload (r::rs)).head? d r rs (Or.inl hp)
   have h := Runs.loop_true (f := fun c : Option Letter × Local => c.1.isSome)
     (by simp [st,state,payload_head]) hb ih
   exact h.mono (by simp only [List.length_cons,Nat.mul_add,Nat.mul_one]; omega)

lemma scanBody_pick {n} (a : Bool) (buf : Option Letter) (d : Data)
    (r : SerialGaussian.Row (n+1)) (rs : List (SerialGaussian.Row (n+1))) (hr : r.head ≠ 0) :
 Runs scanBody (st (ctrl 0 a) buf {d with scan := payload (r::rs), pivBack := []})
   (st (ctrl r.head a) (payload rs).head?
     {d with scan := payload rs, pivBack := (r.tail.entries.map some).reverse})
   (2*(n+1)+12) := by
 let c' : Control := ⟨0,r.head,a⟩
 let c'' : Control := ⟨r.head,r.head,a⟩
 have hp : Runs (.atom (.pop .scan (fun (c : Option Letter × Local) a =>
       (none,(none,{c.2.2 with factor := (a.bind id).getD 0}))) .done))
     (st (ctrl 0 a) buf {d with scan := payload (r::rs),pivBack := []})
     (st c' none {d with scan := r.tail.entries.map some ++ none::payload rs,pivBack := []}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,payload_cons,entries_head_tail,c',ctrl,Data.tapes]
 have hl : Runs (.atom (.load (fun c : Option Letter × Local =>
       (c.1,(none,{c.2.2 with pivot := c.2.2.factor}))) .done))
     (st c' none {d with scan := r.tail.entries.map some ++ none::payload rs,pivBack := []})
     (st c'' none {d with scan := r.tail.entries.map some ++ none::payload rs,pivBack := []}) 1 := by
   exact Runs.atom_of _ _ _ rfl
 have hm := moveRow_runs Reg.scan Reg.pivBack (by decide) (fun (_ : Local) a => a)
   (none,c'') none d.tapes r.tail.entries (payload rs) []
 have hm' : Runs (moveRow Reg.scan Reg.pivBack (fun (_ : Local) a => a))
      (st c'' none {d with scan := r.tail.entries.map some ++ none::payload rs,pivBack := []})
      (st c'' none {d with scan := payload rs,pivBack := (r.tail.entries.map some).reverse})
      (2*(n+1)+5) := by simpa [st] using hm
 have hc := Runs.cond_true (b := skipRow Reg.scan)
    (f := fun c : Option Letter × Local => c.2.2.pivot == 0 && c.2.2.factor != 0)
    (s := st c' none {d with scan := r.tail.entries.map some ++ none::payload rs,pivBack := []})
    (by simpa [st,state,c'] using hr) (hl.seq hm')
 have hf : Runs (.atom (.peek .scan (fun (c : Option Letter × Local) a =>
       (a,(none,{c.2.2 with factor := 0}))) .done))
     (st c'' none {d with scan := payload rs,pivBack := (r.tail.entries.map some).reverse})
     (st (ctrl r.head a) (payload rs).head?
       {d with scan := payload rs,pivBack := (r.tail.entries.map some).reverse}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,c'',ctrl,Data.tapes]
 convert hp.seq (hc.seq hf) using 1 <;> first | rfl | omega

def pivotHead {n} (p : Option (SerialGaussian.Row (n+1))) : Scalar := p.elim 0 Row.head

def pivotTail {n} (p : Option (SerialGaussian.Row (n+1))) : List Letter :=
 p.elim [] (fun r => r.tail.entries.map some)

lemma scanLoop_initial {n} (a : Bool) (d : Data) (rs : List (SerialGaussian.Row (n+1))) :
 Runs scanLoop (st (ctrl 0 a) (payload rs).head? {d with scan := payload rs,pivBack := []})
   (st (ctrl (pivotHead (pivot rs)) a) none
      {d with scan := [],pivBack := (pivotTail (pivot rs)).reverse})
   ((2*(n+1)+13)*rs.length+1) := by
 induction rs with
 | nil => exact Runs.loop_false rfl
 | cons r rs ih =>
   by_cases hr : r.head = 0
   · have hb := scanBody_skip (ctrl 0 a) (payload (r::rs)).head? {d with pivBack := []} r rs (Or.inr hr)
     have h := Runs.loop_true (f := fun c : Option Letter × Local => c.1.isSome)
       (by simp [st,state,payload_head]) hb ih
     simpa [scanLoop,pivot,List.find?_cons,hr,← Row.head_decode,List.length_cons,Nat.mul_add,
       Nat.add_assoc,Nat.add_comm,Nat.add_left_comm] using
       h.mono (show 1+(2*(n+1)+10+((2*(n+1)+13)*rs.length+1)) ≤
         (2*(n+1)+13)*(rs.length+1)+1 by simp only [Nat.mul_add,Nat.mul_one]; omega)
   · have hb := scanBody_pick a (payload (r::rs)).head? d r rs hr
     have ht := scanLoop_nonzero r.head hr a
       {d with pivBack := (r.tail.entries.map some).reverse} rs
     have h := Runs.loop_true (f := fun c : Option Letter × Local => c.1.isSome)
       (by simp [st,state,payload_head]) hb ht
     convert h using 1 <;>
       simp [scanLoop,pivot,hr,-Row.head_decode,pivotHead,pivotTail,List.length_cons]; ring

def findPivot : Prog :=
 .seq (.atom (.load (fun c => (c.1,(none,ctrl 0 c.2.2.answer))) .done))
 (.seq (copy .mat .scan .back)
  (.seq scanMatrix (moveRev .pivBack .piv (fun _ a => a))))

lemma pivotTail_length {n} (p : Option (SerialGaussian.Row (n+1))) :
 (pivotTail p).length ≤ n+1 := by
 cases p <;> simp [pivotTail]

lemma findPivot_runs {n} (c : Control) (buf : Option Letter) (d : Data)
    (rs : List (SerialGaussian.Row (n+1))) :
 Runs findPivot
   (st c buf {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := []})
   (st (ctrl (pivotHead (pivot rs)) c.answer) none
     {d with mat := payload rs,back := [],scan := [],piv := pivotTail (pivot rs),pivBack := []})
   (30*(rs.length+1)*(n+3)) := by
 let d' : Data := {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := []}
 have hl : Runs (.atom (.load (fun c : Option Letter × Local =>
       (c.1,(none,ctrl 0 c.2.2.answer))) .done))
     (st c buf d') (st (ctrl 0 c.answer) buf d') 1 := Runs.atom_of _ _ _ rfl
 have hc := copy_runs (σ := Local) Reg.mat Reg.scan Reg.back (by decide) (by decide) (by decide)
   (none,ctrl 0 c.answer) buf d'.tapes (payload rs) []
 have hc' : Runs (copy Reg.mat Reg.scan Reg.back) (st (ctrl 0 c.answer) buf d')
   (st (ctrl 0 c.answer) none {d' with scan := payload rs}) (4*(payload rs).length+7) := by
   simpa [st,d'] using hc
 have hp : Runs (peek Reg.scan) (st (ctrl 0 c.answer) none {d' with scan := payload rs})
   (st (ctrl 0 c.answer) (payload rs).head? {d' with scan := payload rs}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,Data.tapes]
 have hs := scanLoop_initial c.answer d' rs
 have hs' : Runs scanMatrix (st (ctrl 0 c.answer) none {d' with scan := payload rs})
   (st (ctrl (pivotHead (pivot rs)) c.answer) none
     {d' with scan := [],pivBack := (pivotTail (pivot rs)).reverse})
   ((2*(n+1)+13)*rs.length+3) := by
   convert hp.seq hs using 1 <;> first | rfl | omega
 have hm := moveRev_runs Reg.pivBack Reg.piv (by decide) (fun (_ : Local) a => a)
   (none,ctrl (pivotHead (pivot rs)) c.answer) none d'.tapes (pivotTail (pivot rs)).reverse []
 have hm' : Runs (moveRev Reg.pivBack Reg.piv (fun (_ : Local) a => a))
    (st (ctrl (pivotHead (pivot rs)) c.answer) none
      {d' with scan := [],pivBack := (pivotTail (pivot rs)).reverse})
    (st (ctrl (pivotHead (pivot rs)) c.answer) none {d' with piv := pivotTail (pivot rs)})
    (2*(pivotTail (pivot rs)).length+3) := by simpa [st,d'] using hm
 have h := hl.seq (hc'.seq (hs'.seq hm'))
 apply h.mono
 rw [payload_length]
 have ht := pivotTail_length (pivot rs)
 nlinarith

lemma entries_reduce {n} (p r : SerialGaussian.Row (n+1)) :
 (p.reduce r).entries = List.zipWith (fun x y => x-(r.head/p.head)*y) r.tail.entries p.tail.entries := by
 simp only [SerialGaussian.Row.entries,Row.tail,Row.reduce]
 rw [List.zipWith_append (by simp [r.length_eq,p.length_eq])]
 rfl

def reduceInner : Prog :=
 .seq (.cond (fun c => c.2.2.pivot == 0)
    (moveRow .mat .back (fun _ a => a))
    (zipRow .mat .back .piv .pivBack (fun c x y => x-c.factor*y)))
   (moveRev .pivBack .piv (fun _ a => a))

def reduceBody : Prog :=
 .seq (.atom (.pop .mat (fun c a =>
   (none,(none,{c.2.2 with factor := (a.bind id).getD 0 / c.2.2.pivot}))) .done))
 (.seq reduceInner
   (.atom (.push .back (fun _ => none)
      (.peek .mat (fun c a => (a,(none,{c.2.2 with factor := 0}))) .done))))

def reduceLoop : Prog := .loop (fun c => c.1.isSome) reduceBody

def reduceMatrix : Prog := .seq (peek .mat) reduceLoop

def reducedRow {n} (p : Option (SerialGaussian.Row (n+1))) (r : SerialGaussian.Row (n+1)) : SerialGaussian.Row n :=
 p.elim r.tail (fun p => p.reduce r)

def reduceControl {n} (p : Option (SerialGaussian.Row (n+1))) (r : SerialGaussian.Row (n+1)) (a : Bool) : Control :=
 ⟨pivotHead p,r.head/pivotHead p,a⟩

lemma reduceInner_runs {n} (p : Option (SerialGaussian.Row (n+1)))
    (hp : ∀ q ∈ p, q.head ≠ 0) (r : SerialGaussian.Row (n+1)) (a : Bool)
    (d : Data) (xs bs : List Letter) :
 Runs reduceInner
   (st (reduceControl p r a) none
     {d with mat := r.tail.entries.map some ++ none::xs,back := bs,piv := pivotTail p,pivBack := []})
   (st (reduceControl p r a) none
     {d with mat := xs,back := ((reducedRow p r).entries.map some).reverse ++ bs,piv := pivotTail p,pivBack := []})
   (4*(n+1)+10) := by
 cases p with
 | none =>
   let c := reduceControl none r a
   have hm := moveRow_runs Reg.mat Reg.back (by decide) (fun (_ : Local) a => a)
     (none,c) none ({d with piv := [],pivBack := []}).tapes r.tail.entries xs bs
   have hm' : Runs (moveRow Reg.mat Reg.back (fun (_ : Local) a => a))
     (st c none {d with mat := r.tail.entries.map some ++ none::xs,back := bs,piv := [],pivBack := []})
     (st c none {d with mat := xs,back := (r.tail.entries.map some).reverse ++ bs,piv := [],pivBack := []})
     (2*(n+1)+5) := by simpa [st] using hm
   have hc := Runs.cond_true (f := fun c : Option Letter × Local => c.2.2.pivot == 0)
     (b := zipRow Reg.mat Reg.back Reg.piv Reg.pivBack (fun (c : Control) x y => x-c.factor*y))
     (by simp [st,state,c,reduceControl,pivotHead]) hm'
   have hr := moveRev_runs Reg.pivBack Reg.piv (by decide) (fun (_ : Local) a => a)
     (none,c) none ({d with mat := xs,back := (r.tail.entries.map some).reverse ++ bs}).tapes [] []
   have hr' : Runs (moveRev Reg.pivBack Reg.piv (fun (_ : Local) a => a))
     (st c none {d with mat := xs,back := (r.tail.entries.map some).reverse ++ bs,piv := [],pivBack := []})
     (st c none {d with mat := xs,back := (r.tail.entries.map some).reverse ++ bs,piv := [],pivBack := []}) 3 := by
     simpa [st,Function.comp_def] using hr
   exact (hc.seq hr').mono (by omega)
 | some p =>
   let c := reduceControl (some p) r a
   have hm := zipRow_runs Reg.mat Reg.back Reg.piv Reg.pivBack
     (by decide) (by decide) (by decide) (by decide) (by decide) (by decide)
     (fun (c : Control) x y => x-c.factor*y) c none d.tapes r.tail.entries p.tail.entries
     (by simp) xs bs []
   have hm' : Runs (zipRow Reg.mat Reg.back Reg.piv Reg.pivBack (fun (c : Control) x y => x-c.factor*y))
     (st c none {d with mat := r.tail.entries.map some ++ none::xs,back := bs,piv := p.tail.entries.map some,pivBack := []})
     (st c none {d with mat := xs,back := ((p.reduce r).entries.map some).reverse ++ bs,piv := [],pivBack := (p.tail.entries.map some).reverse}) (2*(n+1)+5) := by
     simpa [st,c,reduceControl,pivotHead,entries_reduce] using hm
   have hc := Runs.cond_false (f := fun c : Option Letter × Local => c.2.2.pivot == 0)
     (a := moveRow Reg.mat Reg.back (fun (_ : Local) a => a))
     (by simpa [st,state,c,reduceControl,pivotHead] using hp p (by simp)) hm'
   have hr := moveRev_runs Reg.pivBack Reg.piv (by decide) (fun (_ : Local) a => a)
     (none,c) none ({d with mat := xs,back := ((p.reduce r).entries.map some).reverse ++ bs}).tapes
     (p.tail.entries.map some).reverse []
   have hr' : Runs (moveRev Reg.pivBack Reg.piv (fun (_ : Local) a => a))
     (st c none {d with mat := xs,back := ((p.reduce r).entries.map some).reverse ++ bs,piv := [],pivBack := (p.tail.entries.map some).reverse})
     (st c none {d with mat := xs,back := ((p.reduce r).entries.map some).reverse ++ bs,piv := p.tail.entries.map some,pivBack := []}) (2*(n+1)+3) := by
     simpa [st,Function.comp_def] using hr
   convert hc.seq hr' using 1 <;> first | rfl | omega

lemma reduceBody_runs {n} (p : Option (SerialGaussian.Row (n+1)))
    (hp : ∀ q ∈ p, q.head ≠ 0) (r : SerialGaussian.Row (n+1)) (rs) (a : Bool)
    (buf : Option Letter) (d : Data) (bs : List Letter) :
 Runs reduceBody
   (st (ctrl (pivotHead p) a) buf
     {d with mat := payload (r::rs),back := bs,piv := pivotTail p,pivBack := []})
   (st (ctrl (pivotHead p) a) (payload rs).head?
     {d with mat := payload rs,back := (payload [reducedRow p r]).reverse ++ bs,piv := pivotTail p,pivBack := []})
   (4*(n+1)+14) := by
 have ho : Runs (.atom (.pop .mat (fun (c : Option Letter × Local) a =>
       (none,(none,{c.2.2 with factor := (a.bind id).getD 0/c.2.2.pivot}))) .done))
     (st (ctrl (pivotHead p) a) buf
       {d with mat := payload (r::rs),back := bs,piv := pivotTail p,pivBack := []})
     (st (reduceControl p r a) none
       {d with mat := r.tail.entries.map some ++ none::payload rs,back := bs,piv := pivotTail p,pivBack := []}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,Data.tapes,payload_cons,entries_head_tail,ctrl,reduceControl]
 have hi := reduceInner_runs p hp r a d (payload rs) bs
 have hf : Runs (.atom (.push .back (fun _ : Option Letter × Local => none)
       (.peek .mat (fun (c : Option Letter × Local) a => (a,(none,{c.2.2 with factor := 0}))) .done)))
     (st (reduceControl p r a) none
       {d with mat := payload rs,back := ((reducedRow p r).entries.map some).reverse ++ bs,piv := pivotTail p,pivBack := []})
     (st (ctrl (pivotHead p) a) (payload rs).head?
       {d with mat := payload rs,back := (payload [reducedRow p r]).reverse ++ bs,piv := pivotTail p,pivBack := []}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,Data.tapes,payload,SerialGaussian.Row.entries,ctrl,reduceControl,List.reverse_append]
 convert ho.seq (hi.seq hf) using 1 <;> first | rfl | omega

lemma payload_append {n} (xs ys : List (SerialGaussian.Row n)) :
 payload (xs++ys) = payload xs ++ payload ys := by simp [payload]

lemma reduceLoop_runs {n} (p : Option (SerialGaussian.Row (n+1)))
    (hp : ∀ q ∈ p, q.head ≠ 0) (a : Bool) (d : Data)
    (rs : List (SerialGaussian.Row (n+1))) (bs : List Letter) :
 Runs reduceLoop
   (st (ctrl (pivotHead p) a) (payload rs).head?
     {d with mat := payload rs,back := bs,piv := pivotTail p,pivBack := []})
   (st (ctrl (pivotHead p) a) none
     {d with mat := [],back := (payload (rs.map (reducedRow p))).reverse ++ bs,piv := pivotTail p,pivBack := []})
   ((4*(n+1)+15)*rs.length+1) := by
 induction rs generalizing bs with
 | nil => simpa [payload,reduceLoop] using
     (Runs.loop_false (b := reduceBody) (f := fun c : Option Letter × Local => c.1.isSome)
       (s := st (ctrl (pivotHead p) a) none {d with mat := [],back := bs,piv := pivotTail p,pivBack := []}) rfl)
 | cons r rs ih =>
   have hb := reduceBody_runs p hp r rs a (payload (r::rs)).head? d bs
   have ht := ih ((payload [reducedRow p r]).reverse ++ bs)
   have h := Runs.loop_true (f := fun c : Option Letter × Local => c.1.isSome)
     (by simp [st,state,payload_head]) hb ht
   convert h using 1 <;>
     simp [reduceLoop,payload,List.map_cons,List.reverse_append,List.append_assoc] ; ring

lemma reduceMatrix_runs {n} (p : Option (SerialGaussian.Row (n+1)))
    (hp : ∀ q ∈ p, q.head ≠ 0) (a : Bool) (buf : Option Letter) (d : Data)
    (rs : List (SerialGaussian.Row (n+1))) :
 Runs reduceMatrix
   (st (ctrl (pivotHead p) a) buf
     {d with mat := payload rs,back := [],piv := pivotTail p,pivBack := []})
   (st (ctrl (pivotHead p) a) none
     {d with mat := [],back := (payload (rs.map (reducedRow p))).reverse,piv := pivotTail p,pivBack := []})
   ((4*(n+1)+15)*rs.length+3) := by
 have hpeek : Runs (peek Reg.mat)
     (st (ctrl (pivotHead p) a) buf {d with mat := payload rs,back := [],piv := pivotTail p,pivBack := []})
     (st (ctrl (pivotHead p) a) (payload rs).head? {d with mat := payload rs,back := [],piv := pivotTail p,pivBack := []}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,Data.tapes]
 have h := hpeek.seq (reduceLoop_runs p hp a d rs [])
 have h' := h.mono (show 1+(1+((4*(n+1)+15)*rs.length+1)) ≤ (4*(n+1)+15)*rs.length+3 by omega)
 simpa only [List.append_nil,reduceMatrix] using h'

def eliminate : Prog :=
 .seq findPivot (.seq reduceMatrix
   (.seq (moveRev .back .mat (fun _ a => a))
      (.seq (clear .piv) (.atom (.load (fun c => (none,(none,ctrl 0 c.2.2.answer))) .done)))))

def nextRows {n} (rs : List (SerialGaussian.Row (n+1))) : List (SerialGaussian.Row n) :=
 rs.map (reducedRow (pivot rs))

@[simp] lemma nextRows_length {n} (rs : List (SerialGaussian.Row (n+1))) :
 (nextRows rs).length = rs.length := by simp [nextRows]

lemma pivot_nonzero {n} (rs : List (SerialGaussian.Row (n+1))) :
 ∀ q ∈ pivot rs, q.head ≠ 0 := by
 intro q hq
 have h := List.find?_some hq
 simpa [pivot,← Row.head_decode] using h

lemma solve_next {n} (rs : List (SerialGaussian.Row (n+1))) :
 solve rs = solve (nextRows rs) := by
 cases hp : pivot rs <;> simp only [solve,nextRows,hp] <;> rfl

lemma eliminate_runs {n} (c : Control) (buf : Option Letter) (d : Data)
    (rs : List (SerialGaussian.Row (n+1))) :
 Runs eliminate
   (st c buf {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := []})
   (st (ctrl 0 c.answer) none
     {d with mat := payload (nextRows rs),back := [],scan := [],piv := [],pivBack := []})
   (100*(rs.length+1)*(n+3)) := by
 let d' : Data := {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := []}
 let p := pivot rs
 have hf := findPivot_runs c buf d rs
 have hr := reduceMatrix_runs p (pivot_nonzero rs) c.answer none d' rs
 have hm := moveRev_runs Reg.back Reg.mat (by decide) (fun (_ : Local) a => a)
   (none,ctrl (pivotHead p) c.answer) none ({d' with piv := pivotTail p}).tapes
   (payload (nextRows rs)).reverse []
 have hm' : Runs (moveRev Reg.back Reg.mat (fun (_ : Local) a => a))
     (st (ctrl (pivotHead p) c.answer) none {d' with mat := [],back := (payload (nextRows rs)).reverse,piv := pivotTail p})
     (st (ctrl (pivotHead p) c.answer) none {d' with mat := payload (nextRows rs),piv := pivotTail p})
     (2*(payload (nextRows rs)).length+3) := by simpa [st,d',Function.comp_def] using hm
 have hc := clear_runs (σ := Local) Reg.piv (none,ctrl (pivotHead p) c.answer) none
   ({d' with mat := payload (nextRows rs)}).tapes (pivotTail p)
 have hc' : Runs (clear Reg.piv)
     (st (ctrl (pivotHead p) c.answer) none {d' with mat := payload (nextRows rs),piv := pivotTail p})
     (st (ctrl (pivotHead p) c.answer) none {d' with mat := payload (nextRows rs)})
     (2*(pivotTail p).length+3) := by simpa [st,d'] using hc
 have hl : Runs (.atom (.load (fun c : Option Letter × Local =>
       (none,(none,ctrl 0 c.2.2.answer))) .done))
     (st (ctrl (pivotHead p) c.answer) none {d' with mat := payload (nextRows rs)})
     (st (ctrl 0 c.answer) none {d' with mat := payload (nextRows rs)}) 1 := Runs.atom_of _ _ _ rfl
 have h := hf.seq (hr.seq (hm'.seq (hc'.seq hl)))
 apply h.mono
 rw [payload_length,nextRows_length]
 have ht := pivotTail_length p
 nlinarith

def normal : {n : ℕ} → List (SerialGaussian.Row n) → List (SerialGaussian.Row 0)
 | 0,rs => rs
 | _+1,rs => normal (nextRows rs)

@[simp] lemma normal_length {n} (rs : List (SerialGaussian.Row n)) :
 (normal rs).length = rs.length := by
 induction n with
 | zero => rfl
 | succ n ih => simpa [normal] using ih (nextRows rs)

lemma solve_normal {n} (rs : List (SerialGaussian.Row n)) : solve (normal rs) = solve rs := by
 induction n with
 | zero => rfl
 | succ n ih => rw [normal,ih,← solve_next]

def eliminationBody : Prog := .seq eliminate
 (.atom (.pop .width (fun c _ => c) (.peek .width (fun c a => (a,c.2)) .done)))

def eliminationLoop : Prog := .loop (fun c => c.1.isSome) eliminationBody

lemma eliminationBody_runs {n} (a : Bool) (buf : Option Letter) (d : Data)
    (rs : List (SerialGaussian.Row (n+1))) (ws : List Letter) :
 Runs eliminationBody
   (st (ctrl 0 a) buf {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := [],width := none::ws})
   (st (ctrl 0 a) ws.head?
     {d with mat := payload (nextRows rs),back := [],scan := [],piv := [],pivBack := [],width := ws})
   (100*(rs.length+1)*(n+3)+2) := by
 have he := eliminate_runs (ctrl 0 a) buf {d with width := none::ws} rs
 have hp : Runs (.atom (.pop .width (fun c : Option Letter × Local => fun _ => c)
       (.peek .width (fun (c : Option Letter × Local) a => (a,c.2)) .done)))
     (st (ctrl 0 a) none {d with mat := payload (nextRows rs),back := [],scan := [],piv := [],pivBack := [],width := none::ws})
     (st (ctrl 0 a) ws.head? {d with mat := payload (nextRows rs),back := [],scan := [],piv := [],pivBack := [],width := ws}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,Data.tapes]
 convert he.seq hp using 1 <;> first | rfl | omega

lemma eliminationLoop_runs {n} (a : Bool) (d : Data) (rs : List (SerialGaussian.Row n)) :
 Runs eliminationLoop
   (st (ctrl 0 a) (List.replicate n (none : Letter)).head?
     {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := [],width := List.replicate n none})
   (st (ctrl 0 a) none
     {d with mat := payload (normal rs),back := [],scan := [],piv := [],pivBack := [],width := []})
   (200*(rs.length+1)*(n+3)^2) := by
 induction n with
 | zero =>
   apply (Runs.loop_false rfl).mono
   norm_num
   omega
 | succ n ih =>
   have hb := eliminationBody_runs a (List.replicate (n+1) (none : Letter)).head? d rs
     (List.replicate n none)
   have ht := ih (nextRows rs)
   have h := Runs.loop_true (f := fun c : Option Letter × Local => c.1.isSome)
     (by simp [st,state,List.replicate_succ]) hb ht
   have h' : Runs eliminationLoop
       (st (ctrl 0 a) (List.replicate (n+1) (none : Letter)).head?
         {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := [],width := List.replicate (n+1) none})
       (st (ctrl 0 a) none
         {d with mat := payload (normal rs),back := [],scan := [],piv := [],pivBack := [],width := []})
       (1+(100*(rs.length+1)*(n+3)+2+200*(rs.length+1)*(n+3)^2)) := by
     simpa only [eliminationLoop,List.replicate_succ,normal,nextRows_length] using h
   exact h'.mono (by nlinarith)

def zeroBody : Prog := .atom
 (.pop .mat (fun c a => (none,(none,{c.2.2 with answer := c.2.2.answer && ((a.bind id).getD 0 == 0)})))
  (.pop .mat (fun c _ => c) (.peek .mat (fun c a => (a,c.2)) .done)))

def zeroLoop : Prog := .loop (fun c => c.1.isSome) zeroBody

def checkZero : Prog :=
 .seq (.atom (.load (fun _ => (none,(none,ctrl 0 true)))
   (.peek .mat (fun c a => (a,c.2)) .done)))
 (.seq zeroLoop (.atom (.push .output (fun c => some (if c.2.2.answer then 1 else 0)) .done)))

lemma payload_zero_cons (r : SerialGaussian.Row 0) (rs) :
 payload (r::rs) = some r.rhs :: none :: payload rs := by
 have hc : r.coeff = [] := List.eq_nil_of_length_eq_zero r.length_eq
 simp [payload, hc]

lemma zeroLoop_runs (a : Bool) (d : Data) (rs : List (SerialGaussian.Row 0)) :
 Runs zeroLoop (st (ctrl 0 a) (payload rs).head? {d with mat := payload rs})
   (st (ctrl 0 (a && solve rs)) none {d with mat := []}) (2*rs.length+1) := by
 induction rs generalizing a with
 | nil => simpa [zeroLoop,solve,payload,ctrl] using
     (Runs.loop_false (b := zeroBody) (f := fun c : Option Letter × Local => c.1.isSome)
       (s := st (ctrl 0 a) none {d with mat := []}) rfl)
 | cons r rs ih =>
   have hb : Runs zeroBody (st (ctrl 0 a) (payload (r::rs)).head? {d with mat := payload (r::rs)})
       (st (ctrl 0 (a && (r.rhs == 0))) (payload rs).head? {d with mat := payload rs}) 1 := by
     apply Runs.atom_of
     simp [Action.run,st,state,ctrl,Data.tapes,payload_zero_cons]
   have h := Runs.loop_true (f := fun c : Option Letter × Local => c.1.isSome)
     (by simp [st,state,payload_zero_cons]) hb (ih (a && (r.rhs == 0)))
   convert h using 1 <;> simp [zeroLoop,solve,Bool.and_assoc] ; omega

lemma checkZero_runs (c : Control) (buf : Option Letter) (d : Data) (rs : List (SerialGaussian.Row 0)) :
 Runs checkZero (st c buf {d with mat := payload rs,output := []})
   (st (ctrl 0 (solve rs)) none {d with mat := [],output := boolCode (solve rs)}) (2*rs.length+5) := by
 have hi : Runs (.atom (.load (fun _ : Option Letter × Local => (none,(none,ctrl 0 true)))
       (.peek .mat (fun (c : Option Letter × Local) a => (a,c.2)) .done)))
     (st c buf {d with mat := payload rs,output := []})
     (st (ctrl 0 true) (payload rs).head? {d with mat := payload rs,output := []}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,Data.tapes]
 have hz := zeroLoop_runs true {d with output := []} rs
 have ho : Runs (.atom (.push .output (fun c : Option Letter × Local =>
       some (if c.2.2.answer then 1 else 0)) .done))
     (st (ctrl 0 (true && solve rs)) none {d with mat := [],output := []})
     (st (ctrl 0 (solve rs)) none {d with mat := [],output := boolCode (solve rs)}) 1 := by
   apply Runs.atom_of
   simp [Action.run,st,state,Data.tapes,ctrl,boolCode]
 convert hi.seq (hz.seq ho) using 1 <;> first | rfl | omega

def solver : Prog := .seq (peek .width) (.seq eliminationLoop checkZero)

lemma solver_runs {n} (d : Data) (rs : List (SerialGaussian.Row n)) :
 Runs solver
   (st (ctrl 0 true) none {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := [], width := List.replicate n none,output := []})
   (st (ctrl 0 (solve rs)) none {d with mat := [],back := [],scan := [],piv := [],pivBack := [], width := [],output := boolCode (solve rs)})
   (300*(rs.length+1)*(n+3)^2) := by
 have hp : Runs (peek .width)
     (st (ctrl 0 true) none {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := [], width := List.replicate n none,output := []})
     (st (ctrl 0 true) (List.replicate n (none : Letter)).head?
       {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := [], width := List.replicate n none,output := []}) 1 := by
   apply Runs.atom_of
   rfl
 have he := eliminationLoop_runs true {d with output := []} rs
 have hz := checkZero_runs (ctrl 0 true) none
     {d with back := [],scan := [],piv := [],pivBack := [],width := []}
     (normal rs)
 have h := hp.seq (he.seq hz)
 have h' : Runs solver
   (st (ctrl 0 true) none {d with mat := payload rs,back := [],scan := [],piv := [],pivBack := [], width := List.replicate n none,output := []})
   (st (ctrl 0 (solve rs)) none {d with mat := [],back := [],scan := [],piv := [],pivBack := [], width := [],output := boolCode (solve rs)})
   (1+(1+(1+(200*(rs.length+1)*(n+3)^2+(2*rs.length+5))))) := by
   simpa only [solver,solve_normal,normal_length] using h
 exact h'.mono (by
   have hs : 1 ≤ (n+3)^2 := Nat.succ_le_iff.mpr (pow_pos (by omega) 2)
   have hm := Nat.mul_le_mul_left (rs.length+1) hs
   nlinarith)

end CPTSeparation.GaussMachine

end OAI