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

namespace OAI

namespace MatchingFPRAS.BinaryArithmetic
open Turing MachineCost

inductive CopyPhase
  | seek | append (b : Bool) | rewind | finish | restore
  deriving DecidableEq, Fintype, Inhabited

def bitSymbol (b : Bool) : Symbol := if b then 2 else 1
def markSymbol (b : Bool) : Symbol := if b then 5 else 4
def unmarkSymbol (a : Symbol) : Symbol := if a=4 then 1 else if a=5 then 2 else a
lemma bitSymbol_ne_zero (b : Bool) : bitSymbol b≠0 := by cases b <;> decide
lemma markSymbol_ne_zero (b : Bool) : markSymbol b≠0 := by cases b <;> decide
@[simp] lemma unmark_mark (b : Bool) : unmarkSymbol (markSymbol b)=bitSymbol b := by cases b <;> decide
@[simp] lemma unmark_bit (b : Bool) : unmarkSymbol (bitSymbol b)=bitSymbol b := by cases b <;> decide
@[simp] lemma unmark_three : unmarkSymbol 3=3 := by decide

def copyProgram : CopyPhase → TM1.Stmt Symbol CopyPhase Unit
  | .seek => .branch (fun a _=>a==4 || a==5) (.move .right (.goto (fun _ _=>.seek)))
      (.branch (fun a _=>a==1) (.write (fun _ _=>4) (.goto (fun _ _=>.append false)))
        (.branch (fun a _=>a==2) (.write (fun _ _=>5) (.goto (fun _ _=>.append true)))
          (.move .right (.goto (fun _ _=>.finish)))))
  | .append b => .branch (fun a _=>a==0)
      (.write (fun _ _=>bitSymbol b) (.goto (fun _ _=>.rewind)))
      (.move .right (.goto (fun _ _=>.append b)))
  | .rewind => .branch (fun a _=>a==0)
      (.move .right (.goto (fun _ _=>.seek))) (.move .left (.goto (fun _ _=>.rewind)))
  | .finish => .branch (fun a _=>a==0)
      (.write (fun _ _=>3) (.goto (fun _ _=>.restore)))
      (.move .right (.goto (fun _ _=>.finish)))
  | .restore => .branch (fun a _=>a==0) (.move .right .halt)
      (.write (fun a _=>unmarkSymbol a) (.move .left (.goto (fun _ _=>.restore))))
abbrev copyCfg (s : Option CopyPhase) (L R : List Symbol) : TM1.Cfg Symbol CopyPhase Unit :=
  ⟨s,(),Tape.mk₂ L R⟩
lemma seek_marks (P : List Bool) (L R : List Symbol) :
    MachineCost.run (TM1.step copyProgram) P.length (copyCfg (some .seek) L (P.map markSymbol++R))=
      copyCfg (some .seek) ((P.map markSymbol).reverse++L) R := by
  induction P generalizing L with
  | nil => simp [MachineCost.run,copyCfg]
  | cons b P ih =>
    rw [List.length_cons,MachineCost.run]
    have hs : advance (TM1.step copyProgram) (copyCfg (some .seek) L ((b::P).map markSymbol++R))=
        copyCfg (some .seek) (markSymbol b::L) (P.map markSymbol++R) := by
      cases b <;> simp [advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,markSymbol,Tape.mk₂,Tape.mk',Tape.move]
    rw [hs,ih]
    simp [copyCfg,List.reverse_cons,List.append_assoc]
lemma seek_bit (b : Bool) (L R : List Symbol) :
    advance (TM1.step copyProgram) (copyCfg (some .seek) L (bitSymbol b::R))=
      copyCfg (some (.append b)) L (markSymbol b::R) := by
  cases b <;> simp [advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,markSymbol,bitSymbol,Tape.mk₂,Tape.mk',Tape.write]
lemma append_run (b : Bool) (R L : List Symbol) (hR : ∀ a∈R,a≠0) :
    MachineCost.run (TM1.step copyProgram) (R.length+1) (copyCfg (some (.append b)) L R)=
      copyCfg (some .rewind) (R.reverse++L) [bitSymbol b] := by
  induction R generalizing L with
  | nil => simp [MachineCost.run,advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,Tape.mk₂,Tape.mk',Tape.write]
  | cons a R ih =>
    have ha : (a==0)=false := beq_eq_false_iff_ne.mpr (hR a (by simp))
    rw [List.length_cons,Nat.succ_add,MachineCost.run]
    have hs : advance (TM1.step copyProgram) (copyCfg (some (.append b)) L (a::R))=
        copyCfg (some (.append b)) (a::L) R := by
      simp [advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,Tape.mk₂,Tape.mk',Tape.move,ha]
    rw [hs,ih _ (fun c hc=>hR c (by simp [hc]))]
    simp [copyCfg,List.reverse_cons,List.append_assoc]
lemma rewind_run (L R : List Symbol) (a : Symbol) (ha : a≠0) (hL : ∀ b∈L,b≠0) :
    MachineCost.run (TM1.step copyProgram) (L.length+2) (copyCfg (some .rewind) L (a::R))=
      copyCfg (some .seek) [] (L.reverse++a::R) := by
  have ha' : (a==0)=false := beq_eq_false_iff_ne.mpr ha
  induction L generalizing a R with
  | nil =>
    simp [MachineCost.run,advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,
      Tape.mk₂,Tape.mk',Tape.move,ha',ListBlank.cons_mk]
    apply Quotient.sound
    exact Or.inr ⟨1,rfl⟩
  | cons b L ih =>
    have hb : b≠0:=hL b (by simp)
    rw [List.length_cons,Nat.succ_add,MachineCost.run]
    have hs : advance (TM1.step copyProgram) (copyCfg (some .rewind) (b::L) (a::R))=
        copyCfg (some .rewind) L (b::a::R) := by
      simp [advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,Tape.mk₂,Tape.mk',Tape.move,ha']
    rw [hs,ih (a::R) b hb (fun c hc=>hL c (by simp [hc])) (beq_eq_false_iff_ne.mpr hb)]
    simp [copyCfg,List.reverse_cons,List.append_assoc]

lemma finish_run (R L : List Symbol) (hR : ∀ a∈R,a≠0) :
    MachineCost.run (TM1.step copyProgram) (R.length+1) (copyCfg (some .finish) L R)=
      copyCfg (some .restore) (R.reverse++L) [3] := by
  induction R generalizing L with
  | nil => simp [MachineCost.run,advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,Tape.mk₂,Tape.mk',Tape.write]
  | cons a R ih =>
    have ha : (a==0)=false := beq_eq_false_iff_ne.mpr (hR a (by simp))
    rw [List.length_cons,Nat.succ_add,MachineCost.run]
    have hs : advance (TM1.step copyProgram) (copyCfg (some .finish) L (a::R))=
        copyCfg (some .finish) (a::L) R := by
      simp [advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,Tape.mk₂,Tape.mk',Tape.move,ha]
    rw [hs,ih _ (fun c hc=>hR c (by simp [hc]))]
    simp [copyCfg,List.reverse_cons,List.append_assoc]
lemma restore_run (L R : List Symbol) (a : Symbol) (ha : a≠0) (hL : ∀ b∈L,b≠0) :
    MachineCost.run (TM1.step copyProgram) (L.length+2) (copyCfg (some .restore) L (a::R))=
      copyCfg none [] (L.reverse.map unmarkSymbol++unmarkSymbol a::R) := by
  have ha' : (a==0)=false := beq_eq_false_iff_ne.mpr ha
  induction L generalizing a R with
  | nil =>
    simp [MachineCost.run,advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,
      Tape.mk₂,Tape.mk',Tape.move,Tape.write,ha',ListBlank.cons_mk]
    apply Quotient.sound
    exact Or.inr ⟨1,rfl⟩
  | cons b L ih =>
    have hb : b≠0:=hL b (by simp)
    rw [List.length_cons,Nat.succ_add,MachineCost.run]
    have hs : advance (TM1.step copyProgram) (copyCfg (some .restore) (b::L) (a::R))=
        copyCfg (some .restore) L (b::unmarkSymbol a::R) := by
      simp [advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,Tape.mk₂,Tape.mk',Tape.move,Tape.write,ha']
    rw [hs,ih (unmarkSymbol a::R) b hb (fun c hc=>hL c (by simp [hc])) (beq_eq_false_iff_ne.mpr hb)]
    simp [copyCfg,List.reverse_cons,List.append_assoc]
def copyWord (P Q : List Bool) : List Symbol := P.map markSymbol++Q.map bitSymbol++[3]++P.map bitSymbol
lemma copy_cycle (P Q : List Bool) (b : Bool) :
    MachineCost.run (TM1.step copyProgram) (4*P.length+2*Q.length+8)
      (copyCfg (some .seek) [] (copyWord P (b::Q)))=
      copyCfg (some .seek) [] (copyWord (P++[b]) Q) := by
  let L:=(P.map markSymbol).reverse
  let R:=markSymbol b::(Q.map bitSymbol++[3]++P.map bitSymbol)
  have hR : ∀ a∈R,a≠0 := by
    intro a ha
    simp only [R,List.mem_cons,List.mem_append,List.mem_map,List.not_mem_nil,or_false] at ha
    rcases ha with rfl|((⟨c,hc,rfl⟩|rfl)|⟨c,hc,rfl⟩)
    · exact markSymbol_ne_zero _
    · exact bitSymbol_ne_zero _
    · decide
    · exact bitSymbol_ne_zero _
  have hL : ∀ a∈L,a≠0 := by
    intro a ha
    obtain ⟨c,hc,rfl⟩:=List.mem_map.mp (List.mem_reverse.mp ha)
    exact markSymbol_ne_zero _
  have hRL : ∀ a∈R.reverse++L,a≠0 := by
    intro a ha
    rcases List.mem_append.mp ha with ha|ha
    · exact hR a (List.mem_reverse.mp ha)
    · exact hL a ha
  have hfirst : MachineCost.run (TM1.step copyProgram) (P.length+1)
      (copyCfg (some .seek) [] (copyWord P (b::Q)))=
      copyCfg (some (.append b)) L R := by
    rw [run_add]
    have he : copyWord P (b::Q)=P.map markSymbol++(bitSymbol b::(Q.map bitSymbol++[3]++P.map bitSymbol)) := by
      simp [copyWord,List.append_assoc]
    rw [he,seek_marks]
    simpa only [MachineCost.run,List.append_nil] using seek_bit b L (Q.map bitSymbol++[3]++P.map bitSymbol)
  have hrun : MachineCost.run (TM1.step copyProgram)
      ((P.length+1)+(R.length+1)+((R.reverse++L).length+2))
        (copyCfg (some .seek) [] (copyWord P (b::Q)))=
        copyCfg (some .seek) [] (copyWord (P++[b]) Q) := by
    rw [run_add _ ((P.length+1)+(R.length+1)) ((R.reverse++L).length+2),
      run_add _ (P.length+1) (R.length+1),hfirst,append_run b R L hR,
      rewind_run (R.reverse++L) [] (bitSymbol b) (bitSymbol_ne_zero b) hRL]
    simp [copyWord,R,L,List.reverse_append,List.append_assoc]
  have hlen : (P.length+1)+(R.length+1)+((R.reverse++L).length+2)=
      4*P.length+2*Q.length+8 := by simp [R,L]; omega
  rw [hlen] at hrun
  exact hrun

lemma copy_finish (P : List Bool) :
    MachineCost.run (TM1.step copyProgram) (4*P.length+5)
      (copyCfg (some .seek) [] (copyWord P []))=
      copyCfg none [] ((P.map bitSymbol++[3])++(P.map bitSymbol++[3])) := by
  let R:=P.map bitSymbol
  let L:=(3:Symbol)::(P.map markSymbol).reverse
  have hR : ∀ a∈R,a≠0 := by
    intro a ha
    obtain ⟨c,hc,rfl⟩:=List.mem_map.mp ha
    exact bitSymbol_ne_zero _
  have hRL : ∀ a∈R.reverse++L,a≠0 := by
    intro a ha
    rcases List.mem_append.mp ha with ha|ha
    · exact hR a (List.mem_reverse.mp ha)
    · rcases List.mem_cons.mp ha with rfl|ha
      · decide
      · obtain ⟨c,hc,rfl⟩:=List.mem_map.mp (List.mem_reverse.mp ha)
        exact markSymbol_ne_zero _
  have hfirst : MachineCost.run (TM1.step copyProgram) (P.length+1)
      (copyCfg (some .seek) [] (copyWord P []))=copyCfg (some .finish) L R := by
    rw [run_add]
    have he : copyWord P []=P.map markSymbol++(3::R) := by simp [copyWord,R,List.append_assoc]
    rw [he,seek_marks]
    simp [MachineCost.run,advance,TM1.step,TM1.stepAux,copyProgram,copyCfg,Tape.mk₂,Tape.mk',Tape.move,L]
  have hrun : MachineCost.run (TM1.step copyProgram)
      ((P.length+1)+(R.length+1)+((R.reverse++L).length+2))
        (copyCfg (some .seek) [] (copyWord P []))=
        copyCfg none [] ((P.map bitSymbol++[3])++(P.map bitSymbol++[3])) := by
    rw [run_add _ ((P.length+1)+(R.length+1)) ((R.reverse++L).length+2),
      run_add _ (P.length+1) (R.length+1),hfirst,finish_run R L hR,
      restore_run (R.reverse++L) [] 3 (by decide) hRL]
    simp [R,L,List.reverse_append,List.map_map,Function.comp_def,List.append_assoc]
  have hlen : (P.length+1)+(R.length+1)+((R.reverse++L).length+2)=4*P.length+5 := by
    simp [R,L]
    omega
  rw [hlen] at hrun
  exact hrun
lemma copy_run (P Q : List Bool) :
    ∃ k≤8*(P.length+Q.length+1)*(Q.length+1),
      MachineCost.run (TM1.step copyProgram) k (copyCfg (some .seek) [] (copyWord P Q))=
        copyCfg none [] (((P++Q).map bitSymbol++[3])++((P++Q).map bitSymbol++[3])) := by
  induction Q generalizing P with
  | nil =>
    refine ⟨4*P.length+5,by simp; omega,?_⟩
    simpa using copy_finish P
  | cons b Q ih =>
    obtain ⟨k,hk,he⟩:=ih (P++[b])
    refine ⟨(4*P.length+2*Q.length+8)+k,?_,?_⟩
    · simp only [List.length_append,List.length_cons,List.length_nil] at *
      nlinarith
    · rw [run_add,copy_cycle,he]
      simp [List.append_assoc]
lemma copy_natural (n : ℕ) : ∃ k≤8*(n.size+1)^2,
    MachineCost.run (TM1.step copyProgram) k (TM1.init (encodeNat n))=
      copyCfg none [] (encodeNat n++encodeNat n) := by
  obtain ⟨k,hk,he⟩:=copy_run [] n.bits
  refine ⟨k,?_,?_⟩
  · simpa only [List.length_nil,zero_add,Nat.size_eq_bits_len,pow_two,mul_assoc] using hk
  · have hi : TM1.init (encodeNat n)=copyCfg (some .seek) [] (encodeNat n) := rfl
    rw [hi]
    have henc : n.bits.map bitSymbol++[3]=encodeNat n := rfl
    simpa only [copyWord,List.map_nil,List.nil_append,List.append_nil,henc] using he
lemma copyProgram_cost : programCost copyProgram≤3 := by
  apply Finset.sup_le
  intro p _
  cases p with
  | append b => cases b <;> decide
  | _ => decide

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

end OAI