import OAI.Computability.RationalHitting.BinaryAddition

namespace OAI

namespace RationalHitting.StackLanguage
open Function
variable {K : Type} [DecidableEq K]

lemma wordValue_append (a b : List Bool) :
    wordValue (a++b) = wordValue a + 2^a.length * wordValue b := by
  induction a with
  | nil => simp [wordValue]
  | cons x a ih => simp [wordValue,ih,pow_succ]; ring

/-- Removes the high zero bits of a most-significant-first word. -/
def trimMSD : List Bool → List Bool
  | [] => []
  | false::l => trimMSD l
  | true::l => true::l

lemma trimMSD_length (l : List Bool) : (trimMSD l).length ≤ l.length := by
  induction l with
  | nil => rfl
  | cons b l ih => cases b <;> simp [trimMSD] ; omega

lemma trimMSD_reverse_value (l : List Bool) :
    wordValue (trimMSD l).reverse = wordValue l.reverse := by
  induction l with
  | nil => rfl
  | cons b l ih => cases b <;> simp [trimMSD,List.reverse_cons,wordValue_append,wordValue,ih]

def Canonical (l : List Bool) : Prop := l = [] ∨ ∃ w, l = w++[true]

lemma canonical_tail {b : Bool} {l : List Bool} (h : Canonical (b::l)) : Canonical l := by
  obtain h | ⟨w,hw⟩ := h
  · contradiction
  · cases w with
    | nil => simp only [List.nil_append,List.cons.injEq] at hw; exact Or.inl hw.2
    | cons x w =>
      simp only [List.cons_append,List.cons.injEq] at hw
      exact Or.inr ⟨w,hw.2⟩

lemma canonical_single {b : Bool} (h : Canonical [b]) : b = true := by
  obtain h | ⟨w,hw⟩ := h
  · contradiction
  · cases w with
    | nil => simpa using hw
    | cons a w =>
      have hl := congrArg List.length hw
      simp only [List.length_cons,List.length_append] at hl
      omega

lemma bits_wordValue (l : List Bool) (h : Canonical l) : (wordValue l).bits = l := by
  induction l with
  | nil => rfl
  | cons b l ih =>
    have htail := ih (canonical_tail h)
    have hz : wordValue l = 0 → b = true := by
      intro hh
      have hl : l = [] := by simpa [hh] using htail.symm
      subst l
      exact canonical_single h
    have he : wordValue (b::l) = Nat.bit b (wordValue l) := by
      cases b <;> simp [wordValue,Nat.bit] ; omega
    rw [he,Nat.bits_append_bit _ _ hz,htail]

lemma canonical_trim_reverse (l : List Bool) : Canonical (trimMSD l).reverse := by
  induction l with
  | nil => exact Or.inl rfl
  | cons b l ih =>
    cases b with
    | false => exact ih
    | true => exact Or.inr ⟨l.reverse,by simp [trimMSD]⟩

def normalizeWord (l : List Bool) : List Bool := (trimMSD l.reverse).reverse

@[simp] theorem normalizeWord_value (l : List Bool) : wordValue (normalizeWord l) = wordValue l := by
  simpa [normalizeWord] using trimMSD_reverse_value l.reverse

@[simp] theorem normalizeWord_eq_bits (l : List Bool) : normalizeWord l = (wordValue l).bits := by
  rw [← normalizeWord_value l]
  exact (bits_wordValue _ (canonical_trim_reverse l.reverse)).symm

lemma normalizeWord_length (l : List Bool) : (normalizeWord l).length = (wordValue l).size := by
  rw [normalizeWord_eq_bits,Nat.size_eq_bits_len]

def trimBody (a flag : K) : Program K := .branch a (clear flag) (.drop a) (clear flag)
def trimLoop (a flag : K) : Program K := .loop flag (trimBody a flag)

lemma eval_trimLoop {a flag : K} (haf : a ≠ flag) (s : Store K) (hf : s flag = [true]) :
    ∃ t ≤ 3*(s a).length+6,
      Eval (trimLoop a flag) s (update (update s a (trimMSD (s a))) flag []) t := by
  generalize he : s a = l
  induction l generalizing s with
  | nil =>
    have hh : update (update s a []) flag [] = update s flag [] := by
      ext k; by_cases hka : k=a <;> by_cases hkf : k=flag <;> simp_all
    have hc : Eval (clear flag) s (update s flag []) 3 := by simpa [hf] using eval_clear flag s
    have hb : Eval (trimBody a flag) s (update s flag []) 4 := Eval.branchNone he hc
    have halt : Eval (trimLoop a flag) (update s flag []) (update s flag []) 1 := Eval.whileNil (by simp)
    refine ⟨6,by simp,?_⟩
    simpa [trimLoop,he,trimMSD,hh] using Eval.whileCons (by simp [hf]) hb halt
  | cons b l ih =>
    cases b with
    | false =>
      let s₁ := update s a l
      have hh : s₁ flag = [true] := by simp [s₁,Ne.symm haf,hf]
      obtain ⟨t,ht,hloop⟩ := ih s₁ hh (by simp [s₁])
      have hd : Eval (Program.drop a) s s₁ 1 := by simpa [s₁,he] using Eval.drop a s
      have hb : Eval (trimBody a flag) s s₁ 2 := Eval.branchFalse he hd
      have h := Eval.whileCons (by simp [hf]) hb hloop
      refine ⟨3+t,by simp only [List.length_cons]; omega,?_⟩
      simpa [trimLoop,trimMSD,s₁] using h
    | true =>
      have hh : update (update s a (true::l)) flag [] = update s flag [] := by
        ext k; by_cases hka : k=a <;> by_cases hkf : k=flag <;> simp_all
      have hc : Eval (clear flag) s (update s flag []) 3 := by simpa [hf] using eval_clear flag s
      have hb : Eval (trimBody a flag) s (update s flag []) 4 := Eval.branchTrue he hc
      have halt : Eval (trimLoop a flag) (update s flag []) (update s flag []) 1 := Eval.whileNil (by simp)
      refine ⟨6,by simp,?_⟩
      simpa [trimLoop,trimMSD,hh] using Eval.whileCons (by simp [hf]) hb halt

def normalize (a tmp flag : K) : Program K :=
  .seq (clear tmp) (.seq (clear flag) (.seq (.push flag true)
    (.seq (reverse a tmp) (.seq (trimLoop tmp flag) (reverse tmp a)))))

lemma eval_normalize {a tmp flag : K} (hat : a ≠ tmp) (haf : a ≠ flag) (htf : tmp ≠ flag)
    (s : Store K) :
    ∃ t ≤ 7*(s a).length+2*(s tmp).length+2*(s flag).length+16,
      Eval (normalize a tmp flag) s
        (update (update (update s a (normalizeWord (s a))) tmp []) flag []) t := by
  let s₁ := update s tmp []
  let s₂ := update s₁ flag []
  let s₃ := update s₂ flag [true]
  let s₄ := update (update s₃ a []) tmp (s a).reverse
  have hr : Eval (reverse a tmp) s₃ s₄ (2*(s a).length+1) := by
    simpa [s₄,s₃,s₂,s₁,hat,haf,htf] using eval_reverse hat s₃
  obtain ⟨t,ht,htrim⟩ := eval_trimLoop htf s₄ (by simp [s₄,s₃,Ne.symm htf,Ne.symm haf])
  let s₅ := update (update s₄ tmp (trimMSD (s a).reverse)) flag []
  have htr : Eval (trimLoop tmp flag) s₄ s₅ t := by simpa [s₅,s₄] using htrim
  have hp : Eval (Program.push flag true) s₂ s₃ 1 := by simpa [s₃,s₂] using Eval.push flag true s₂
  have h := Eval.seq (eval_clear tmp s) (Eval.seq (eval_clear flag s₁)
    (Eval.seq hp (Eval.seq hr (Eval.seq htr (eval_reverse (Ne.symm hat) s₅)))))
  have heq : update (update s₅ tmp []) a ((s₅ tmp).reverse++s₅ a) =
      update (update (update s a (normalizeWord (s a))) tmp []) flag [] := by
    ext k
    by_cases hka : k=a <;> by_cases hkt : k=tmp <;> by_cases hkf : k=flag <;>
      simp_all [s₅,s₄,s₃,s₂,s₁,normalizeWord]
  rw [heq] at h
  refine ⟨_,?_,h⟩
  have hl := trimMSD_length (s a).reverse
  simp [s₄] at ht
  simp [s₅,s₄,s₃,s₂,s₁,htf,Ne.symm htf]
  simp only [List.length_reverse] at hl
  omega

end RationalHitting.StackLanguage

end OAI