import OAI.Computability.RationalHitting.Tabulation

namespace OAI

namespace RationalHitting.StackLanguage
open Function

namespace Procedure

def padEmpty (w : List Bool) : Procedure _root_.id _root_.id
    (fun a : List Bool => if a=[] then w else a) where
  Registers := Unit
  finite := inferInstance
  decEq := inferInstance
  input := ()
  output := ()
  program := .branch () (pushWord () w) .skip .skip
  bound := TimeBound.variable+TimeBound.const (2*w.length+3)
  correct a := by
    cases a with
    | nil =>
      refine ⟨1+(2*w.length+1),by simp,?_⟩
      have h := eval_pushWord () w (single () [])
      simp only [single_self,List.append_nil] at h
      have e : update (single () []) () w=single () w := by simp [single]
      rw [e] at h
      exact Eval.branchNone (by simp) h
    | cons b a =>
      refine ⟨2,by simp; omega,?_⟩
      cases b
      · exact Eval.branchFalse (ls:=a) (by simp [single]) (Eval.skip _)
      · exact Eval.branchTrue (ls:=a) (by simp [single]) (Eval.skip _)
  size a := by split_ifs <;> simp_all <;> omega

def wordEmpty : Procedure _root_.id boolCode (fun a : List Bool => a.isEmpty) where
  Registers := Unit
  finite := inferInstance
  decEq := inferInstance
  input := ()
  output := ()
  program := .branch () (.push () true) (.seq (clear ()) (.push () false))
    (.seq (clear ()) (.push () false))
  bound := 2*TimeBound.variable+4
  correct a := by
    cases a with
    | nil =>
      refine ⟨2,by simp,?_⟩
      have h : Eval (.push () true) (single () []) (single () (boolCode true)) 1 := by
        simpa [single,boolCode] using Eval.push () true (single () [])
      exact Eval.branchNone (by simp) h
    | cons b a =>
      have h := Eval.seq (eval_clear_single () (b::a)) (Eval.push () false (fun _ : Unit => []))
      have h' : Eval (.seq (clear ()) (.push () false)) (single () (b::a))
          (single () (boolCode false)) (2*(b::a).length+3) := by
        convert h using 1 <;> simp [single,boolCode]; omega
      refine ⟨1+(2*(b::a).length+3),by simp; omega,?_⟩
      cases b
      · exact Eval.branchFalse (ls:=a) (by simp [single]) h'
      · exact Eval.branchTrue (ls:=a) (by simp [single]) h'
  size a := by simp

end Procedure

namespace Feasible
variable {A : Type} (ca : A → List Bool)

theorem listUncons (z : A) : Feasible (listCode ca) (pairCode ca (listCode ca))
    (fun a => (a.headD z,a.tail)) := by
  refine (show Feasible _root_.id _root_.id _ from ⟨Procedure.padEmpty (codeWord (ca z))⟩).recode
    _ _ _ (listCode ca) (by intro a; rfl) ?_
  intro a
  cases a with
  | nil => simp [pairCode]
  | cons b a =>
    have hne : codeWord (ca b)++listCode ca a≠[] := by
      intro h
      have := congrArg List.length h
      simp at this
    simp [pairCode,hne]

theorem listTail (z : A) : Feasible (listCode ca) (listCode ca) List.tail :=
  (snd ca (listCode ca)).comp (listUncons ca z)

theorem listHeadD (z : A) : Feasible (listCode ca) ca (fun a => a.headD z) :=
  (fst ca (listCode ca)).comp (listUncons ca z)

theorem listEmpty : Feasible (listCode ca) boolCode (List.isEmpty : List A → Bool) := by
  refine (show Feasible _root_.id boolCode _ from ⟨Procedure.wordEmpty⟩).recode
    _ _ _ (listCode ca) (by intro a; rfl) ?_
  intro a
  cases a with
  | nil => rfl
  | cons b a =>
    cases h : ca b <;> simp [listCode,codeWord,h]

end Feasible

lemma listCode_tail_le {A : Type} (ca : A → List Bool) (a : List A) :
    (listCode ca a.tail).length≤(listCode ca a).length := by
  cases a <;> simp

lemma listCode_iterate_tail_le {A : Type} (ca : A → List Bool) (a : List A) (n : ℕ) :
    (listCode ca (List.tail^[n] a)).length≤(listCode ca a).length := by
  induction n with
  | zero => rfl
  | succ n ih =>
    rw [iterate_succ_apply']
    exact (listCode_tail_le ca _).trans ih

namespace Poly
variable {A : Type} [Coding A]

@[fun_prop] theorem listTail [Inhabited A] : Poly (List.tail : List A → List A) :=
  Feasible.listTail code default
@[fun_prop] theorem listHeadD (z : A) : Poly (fun a : List A => a.headD z) :=
  Feasible.listHeadD code z
@[fun_prop] theorem listEmpty : Poly (List.isEmpty : List A → Bool) := Feasible.listEmpty code

theorem iterate {f : A → A} (hf : Poly f) (Q : TimeBound)
    (hQ : ∀ (n : ℕ) (a : A) (i : ℕ), i≤n →
      (code (f^[i] a)).length≤Q.eval ((pairCode unaryCode code (n,a)).length+1)) :
    Poly (fun a : Unary×A => f^[a.1.val] a.2) :=
  (Feasible.iterate hf Q hQ).recode _ _ _ (fun a => (a.1.val,a.2))
    (by intro a; rfl) (by intro a; rfl)

theorem listDrop [Inhabited A] : Poly (fun a : Unary×List A => a.2.drop a.1.val) := by
  have hh := (listTail (A:=A)).iterate TimeBound.variable (by
    intro n a i hi
    have h := listCode_iterate_tail_le (code : A → List Bool) a i
    simp only [TimeBound.eval_variable,pairCode_length,unaryCode_length]
    change (listCode code (List.tail^[i] a)).length≤_ at ⊢
    change _≤2*n+1+(listCode code a).length+1
    omega)
  refine hh.of_eq ?_
  intro a
  exact List.tail_iterate _ _

theorem listGetD [Inhabited A] (z : A) :
    Poly (fun a : Unary×List A => (a.2.drop a.1.val).headD z) :=
  (listHeadD z).comp listDrop

end Poly
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
open Function

/-- Count record delimiters, skipping both the escape bit and payload bit. -/
def recordCount : List Bool → ℕ
  | [] => 0
  | true::w => recordCount w+1
  | false::[] => 0
  | false::_::w => recordCount w

@[simp] lemma recordCount_false (w : List Bool) : recordCount (false::w)=recordCount w.tail := by
  cases w <;> rfl

def countRecordsBody : Program (Fin 2) :=
  .branch 0 .skip (.seq (.drop 0) (.drop 0)) (.seq (.drop 0) (.push 1 true))
def countRecords : Program (Fin 2) := .loop 0 countRecordsBody

lemma drop_both_left (w v : List Bool) :
    Eval (.drop (0 : Fin 2)) (both 0 1 w v) (both 0 1 w.tail v) 1 := by
  convert Eval.drop (0 : Fin 2) (both 0 1 w v) using 1
  funext k; fin_cases k <;> simp [both,single]
lemma push_both_right (w v : List Bool) (b : Bool) :
    Eval (.push (1 : Fin 2) b) (both 0 1 w v) (both 0 1 w (b::v)) 1 := by
  simpa [both] using Eval.push (1 : Fin 2) b (both 0 1 w v)

lemma eval_countRecords (w v : List Bool) : ∃ t≤5*w.length+1,
    Eval countRecords (both 0 1 w v)
      (single 1 (unaryCode (recordCount w)++v)) t := by
  cases w with
  | nil =>
    refine ⟨1,by simp,?_⟩
    simpa [countRecords,both,single,recordCount,unaryCode] using
      (Eval.whileNil (p:=countRecordsBody) (show both (0 : Fin 2) 1 [] v 0=[] by simp [both,single]))
  | cons b w =>
    cases b with
    | false =>
      obtain ⟨t,ht,he⟩ := eval_countRecords w.tail v
      have hb : Eval countRecordsBody (both 0 1 (false::w) v) (both 0 1 w.tail v) 4 :=
        Eval.branchFalse (ls:=w) (by simp [both,single])
          (Eval.seq (drop_both_left (false::w) v) (drop_both_left w v))
      refine ⟨1+4+t,?_,?_⟩
      · simp at ht ⊢; omega
      · simpa only [recordCount_false,countRecords] using Eval.whileCons (by simp [both,single]) hb he
    | true =>
      obtain ⟨t,ht,he⟩ := eval_countRecords w (true::v)
      have hb : Eval countRecordsBody (both 0 1 (true::w) v) (both 0 1 w (true::v)) 4 :=
        Eval.branchTrue (ls:=w) (by simp [both,single])
          (Eval.seq (drop_both_left (true::w) v) (push_both_right w v true))
      have hout : unaryCode (recordCount w)++true::v=unaryCode (recordCount (true::w))++v := by
        simp only [recordCount,unaryCode,List.replicate_add,List.replicate_one,List.append_assoc,
          List.singleton_append]
      rw [hout] at he
      exact ⟨1+4+t,by simp at ht ⊢;omega,Eval.whileCons (by simp [both,single]) hb he⟩
termination_by w.length

lemma recordCount_codeWord (w tail : List Bool) :
    recordCount (codeWord w++tail)=recordCount tail+1 := by
  induction w with
  | nil => rfl
  | cons b w ih => simpa [codeWord,recordCount] using ih

lemma recordCount_listCode {A : Type} (ca : A → List Bool) (l : List A) :
    recordCount (listCode ca l)=l.length := by
  induction l with
  | nil => rfl
  | cons a l ih => simp [recordCount_codeWord,ih]

namespace Procedure

def listLength {A : Type} (ca : A → List Bool) : Procedure (listCode ca) unaryCode List.length where
  Registers := Fin 2
  finite := inferInstance
  decEq := inferInstance
  input := 0
  output := 1
  program := countRecords
  bound := 5*TimeBound.variable+1
  correct a := by
    obtain ⟨t,ht,he⟩ := eval_countRecords (listCode ca a) []
    refine ⟨t,by simp;omega,?_⟩
    simpa [both_nil_right (by decide : (0 : Fin 2)≠1),recordCount_listCode] using he
  size a := by
    have hh := length_le_listCode ca a
    simpa only [unaryCode_length,TimeBound.eval_add,TimeBound.eval_mul,TimeBound.eval_numeral,
      TimeBound.eval_variable] using (by omega : a.length≤5*((listCode ca a).length+1)+1)

end Procedure
namespace Poly

@[fun_prop] theorem listLength {A : Type} [Coding A] : Poly (fun a : List A => Unary.mk a.length) :=
  (show Feasible (listCode code) unaryCode List.length from ⟨Procedure.listLength code⟩).recode
    _ _ _ _root_.id (by intro a; rfl) (by intro a; rfl)

end Poly
end RationalHitting.StackLanguage


namespace RationalHitting.StackLanguage
open Function

lemma range_map_drop_headD {A : Type} (l : List A) (z : A) :
    (List.range l.length).map (fun i => (l.drop i).headD z) = l := by
  apply List.ext_getElem
  · simp
  · intro i hi hj
    simp only [List.getElem_map,List.getElem_range]
    rw [List.headD_eq_getD, List.getD_eq_getElem]
    · exact List.getElem_drop
    · simp;omega

namespace Poly
variable {A B C : Type} [Coding A] [Coding B] [Coding C]

theorem listMap [Inhabited B] {f : A×B → C} (hf : Poly f) :
    Poly (fun a : A×List B => a.2.map (fun b => f (a.1,b))) := by
  have hb : Poly (fun a : (A×List B)×Unary => (a.1.2.drop a.2.val).headD default) :=
    (listGetD (default : B)).comp (show Poly (fun a : (A×List B)×Unary => (a.2,a.1.2)) by fun_prop)
  have hg := hf.comp ((show Poly (fun a : (A×List B)×Unary => a.1.1) by fun_prop).pair hb)
  have ht := hg.tabulate.comp
    ((listLength.comp (show Poly (Prod.snd : A×List B → List B) from snd)).pair
      (show Poly (fun a : A×List B => a) from id))
  refine ht.of_eq ?_
  intro a
  have hh := congrArg (List.map (fun b => f (a.1,b))) (range_map_drop_headD a.2 default)
  rw [List.map_map] at hh
  exact hh

end Poly
end RationalHitting.StackLanguage

end OAI