import Mathlib
import OAI.Combinatorics.MatchingCount.Complexity.GuardMachineBase

namespace OAI

namespace MatchingFPRAS.BinaryArithmetic
open Turing MachineCost

def incrementBits : List Bool → List Bool
  | [] => [true]
  | false::bs => true::bs
  | true::bs => false::incrementBits bs
lemma incrementBits_bits (n : ℕ) : incrementBits n.bits=(n+1).bits := by
  induction n using Nat.binaryRec' with
  | zero => simp [incrementBits]
  | bit b n h ih =>
    cases b with
    | false =>
      have hn : n≠0 := by intro hh; have := h hh; contradiction
      simp only [Nat.bit, Bool.cond_false, Nat.bit0_bits _ hn, incrementBits]
      exact (Nat.bit1_bits n).symm
    | true =>
      simp only [Nat.bits_append_bit _ _ h,incrementBits,ih]
      have hn : n+1≠0 := by omega
      have he : Nat.bit true n+1=2*(n+1) := by simp [Nat.bit]; omega
      rw [he,Nat.bit0_bits _ hn]

def numeral (bs : List Bool) : List Symbol := (bs.map fun b=>if b then 2 else 1)++[3]

def incrementProgram : Bool → TM1.Stmt Symbol Bool Unit
  | false => .branch (fun a _=>a==1)
      (.write (fun _ _=>2) (.goto (fun _ _=>true)))
      (.branch (fun a _=>a==2)
        (.write (fun _ _=>1) (.move .right (.goto (fun _ _=>false))))
        (.write (fun _ _=>2) (.move .right (.write (fun _ _=>3) (.move .left (.goto (fun _ _=>true)))))))
  | true => .branch (fun a _=>a==0) (.move .right .halt) (.move .left (.goto (fun _ _=>true)))
abbrev cfg (s : Option Bool) (L R : List Symbol) : TM1.Cfg Symbol Bool Unit :=
  ⟨s,(),Tape.mk₂ L R⟩
lemma back_step (L R : List Symbol) (a : Symbol) (ha : a≠0) :
    advance (TM1.step incrementProgram) (cfg (some true) L (a::R))=
      ⟨some true,(),(Tape.mk₂ L (a::R)).move .left⟩ := by
  have ha' : (a==0)=false := by simpa using ha
  simp [advance,TM1.step,incrementProgram,TM1.stepAux,cfg,Tape.mk₂,Tape.mk',ha']
lemma back_run (L R : List Symbol) (a : Symbol) (ha : a≠0)
    (hL : ∀ b∈L,b≠0) :
    MachineCost.run (TM1.step incrementProgram) (L.length+2) (cfg (some true) L (a::R))=
      cfg none [] (L.reverse++a::R) := by
  induction L generalizing a R with
  | nil =>
    rw [show ([]:List Symbol).length+2=2 from rfl]
    rw [show 2=1+1 from rfl,MachineCost.run,back_step _ _ _ ha]
    simp [MachineCost.run,advance,TM1.step,incrementProgram,TM1.stepAux,cfg,
      Tape.mk₂,Tape.mk',Tape.move,ListBlank.cons_mk]
    apply Quotient.sound
    exact Or.inr ⟨1,rfl⟩
  | cons b L ih =>
    have hb : b≠0:=hL b (by simp)
    have hL' : ∀ c∈L,c≠0:=fun c hc=>hL c (by simp [hc])
    rw [List.length_cons,Nat.succ_add,MachineCost.run,back_step _ _ _ ha]
    simpa only [cfg,Tape.mk₂,Tape.move_left_mk',ListBlank.head_mk,ListBlank.tail_mk,
      List.headI_cons,List.tail_cons,ListBlank.cons_mk,List.reverse_cons,List.append_assoc,
      List.singleton_append] using ih (a::R) b hb hL'
lemma carry_false (L : List Symbol) (bs : List Bool) :
    advance (TM1.step incrementProgram) (cfg (some false) L (numeral (false::bs)))=
      cfg (some true) L (2::numeral bs) := by
  simp [advance,TM1.step,incrementProgram,TM1.stepAux,cfg,numeral,Tape.mk₂,Tape.mk',Tape.write]
lemma carry_true (L : List Symbol) (bs : List Bool) :
    advance (TM1.step incrementProgram) (cfg (some false) L (numeral (true::bs)))=
      cfg (some false) (1::L) (numeral bs) := by
  simp [advance,TM1.step,incrementProgram,TM1.stepAux,cfg,numeral,Tape.mk₂,Tape.mk',Tape.write,Tape.move]
lemma carry_nil (L : List Symbol) :
    advance (TM1.step incrementProgram) (cfg (some false) L (numeral []))=
      cfg (some true) L [2,3] := by
  simp [advance,TM1.step,incrementProgram,TM1.stepAux,cfg,numeral,Tape.mk₂,Tape.mk',Tape.write,Tape.move]
lemma increment_run (bs : List Bool) (L : List Symbol) (hL : ∀ b∈L,b≠0) :
    ∃ k≤2*bs.length+L.length+3,
      MachineCost.run (TM1.step incrementProgram) k (cfg (some false) L (numeral bs))=
        cfg none [] (L.reverse++numeral (incrementBits bs)) := by
  induction bs generalizing L with
  | nil =>
    refine ⟨(L.length+2)+1,by simp,?_⟩
    rw [MachineCost.run,carry_nil]
    exact back_run L [3] 2 (by decide) hL
  | cons b bs ih =>
    cases b with
    | false =>
      refine ⟨(L.length+2)+1,by simp,?_⟩
      rw [MachineCost.run,carry_false]
      exact back_run L (numeral bs) 2 (by decide) hL
    | true =>
      have hL' : ∀ b∈(1:Symbol)::L,b≠0 := by
        intro b hb
        rcases List.mem_cons.mp hb with rfl|hb
        · decide
        · exact hL b hb
      obtain ⟨k,hk,he⟩:=ih (1::L) hL'
      refine ⟨k+1,by simp only [List.length_cons] at *; omega,?_⟩
      rw [MachineCost.run,carry_true,he]
      simp [cfg,numeral,incrementBits,List.reverse_cons,List.append_assoc]
theorem increment_natural (n : ℕ) : ∃ k≤2*n.size+3,
    MachineCost.run (TM1.step incrementProgram) k (TM1.init (encodeNat n))=
      cfg none [] (encodeNat (n+1)) := by
  obtain ⟨k,hk,he⟩:=increment_run n.bits [] (by simp)
  refine ⟨k,by simpa only [List.length_nil,Nat.add_zero,Nat.size_eq_bits_len] using hk,?_⟩
  have hi : TM1.init (encodeNat n)=cfg (some false) [] (encodeNat n) := rfl
  rw [hi]
  simpa only [List.reverse_nil,List.nil_append,incrementBits_bits,numeral,encodeNat] using he
lemma incrementProgram_cost : programCost incrementProgram≤5 := by
  apply Finset.sup_le
  intro b _
  cases b <;> decide

theorem increment_post (n : ℕ) (bits : Fin (10*n.size+17) → Bool) :
    (MatchingFPRAS.run (PostCompiler.compiled incrementProgram) (encodeNat n) bits).state=none ∧
    (MatchingFPRAS.run (PostCompiler.compiled incrementProgram) (encodeNat n) bits).tape.right₀=
      ListBlank.mk (encodeNat (n+1)) := by
  obtain ⟨k,hk,he⟩:=increment_natural n
  apply PostCompiler.compiled_words incrementProgram (encodeNat n) (encodeNat (n+1)) k
  · rw [he]
  · rw [he]
    change (Tape.mk₁ (encodeNat (n+1))).right₀=ListBlank.mk _
    exact Tape.mk'_right₀ _ _
  · have hc:=incrementProgram_cost
    calc
      programCost incrementProgram*k+2 ≤ 5*(2*n.size+3)+2 :=
        Nat.add_le_add_right (Nat.mul_le_mul hc hk) 2
      _ = 10*n.size+17 := by ring
end MatchingFPRAS.BinaryArithmetic

end OAI