import Mathlib
import OAI.Combinatorics.MatchingCount.Arithmetic.BinaryIncrement
import OAI.Combinatorics.MatchingCount.Arithmetic.BinaryCopy

namespace OAI

namespace MatchingFPRAS.RandomWord
open Turing BinaryArithmetic

abbrev machine : RandomMachine where
  states := 3
  transition s a b :=
    if s=0 then
      if a=3 then some (2,.move .left) else some (1,.write (bitSymbol b))
    else if s=1 then some (0,.move .right)
    else if s=2 then
      if a=0 then some (3,.move .right) else some (2,.move .left)
    else none
abbrev cfg (s : Option (Fin 4)) (L R : List Symbol) : Configuration machine :=
  ⟨s,Tape.mk₂ L R⟩
def execute (xs : List Bool) (c : Configuration machine) : Configuration machine :=
  xs.foldl (tick machine) c
lemma execute_append (xs ys : List Bool) (c : Configuration machine) :
    execute (xs++ys) c=execute ys (execute xs c) := List.foldl_append
lemma execute_cons (b : Bool) (xs : List Bool) (c : Configuration machine) :
    execute (b::xs) c=execute xs (tick machine c b) := rfl
lemma execute_halted (xs : List Bool) (L R : List Symbol) :
    execute xs (cfg none L R)=cfg none L R := by
  induction xs with
  | nil => rfl
  | cons b xs ih => exact ih
lemma draw_two (b c : Bool) (L R : List Symbol) :
    execute [b,c] (cfg (some 0) L (1::R))=cfg (some 0) (bitSymbol b::L) R := by
  simp [execute,tick,machine,cfg,Tape.mk₂,Tape.mk',Tape.write,Tape.move]
def pairCoins (xs : List (Bool×Bool)) : List Bool := xs.flatMap (fun p=>[p.1,p.2])
def drawnWord (xs : List (Bool×Bool)) : List Symbol := xs.map (fun p=>bitSymbol p.1)
lemma draw_forward (xs : List (Bool×Bool)) (L : List Symbol) :
    execute (pairCoins xs) (cfg (some 0) L (List.replicate xs.length 1++[3]))=
      cfg (some 0) ((drawnWord xs).reverse++L) [3] := by
  induction xs generalizing L with
  | nil => rfl
  | cons p xs ih =>
    simp only [pairCoins,List.flatMap_cons,List.length_cons,List.replicate_succ,List.cons_append]
    change execute ([p.1,p.2]++pairCoins xs) (cfg (some 0) L (1::(List.replicate xs.length 1++[3])))=_
    rw [execute_append,draw_two]
    rw [ih]
    simp [drawnWord,List.reverse_cons,List.append_assoc]
lemma reset_tick (L R : List Symbol) (a : Symbol) (ha : a≠0) (b : Bool) :
    tick machine (cfg (some 2) L (a::R)) b=
      ⟨some 2,(Tape.mk₂ L (a::R)).move .left⟩ := by
  simp [tick,machine,Tape.mk₂,Tape.mk',ha]
lemma reset_run (L R : List Symbol) (a : Symbol) (ha : a≠0)
    (hL : ∀ b∈L,b≠0) (xs : List Bool) (hx : xs.length=L.length+2) :
    execute xs (cfg (some 2) L (a::R))=cfg (some 3) [] (L.reverse++a::R) := by
  induction L generalizing a R xs with
  | nil =>
    obtain ⟨b,c,rfl⟩ : ∃ b c,xs=[b,c] := by
      exact List.length_eq_two.mp (by simpa using hx)
    rw [execute_cons,reset_tick _ _ _ ha]
    simp [execute,tick,machine,cfg,Tape.mk₂,Tape.mk',Tape.move,ListBlank.cons_mk]
    apply Quotient.sound
    exact Or.inr ⟨1,rfl⟩
  | cons b L ih =>
    cases xs with
    | nil => simp at hx
    | cons c xs =>
      have hb : b≠0:=hL b (by simp)
      have hL' : ∀ d∈L,d≠0:=fun d hd=>hL d (by simp [hd])
      rw [execute_cons,reset_tick _ _ _ ha]
      have ht : (⟨some 2,(Tape.mk₂ (b::L) (a::R)).move .left⟩ : Configuration machine)=
          cfg (some 2) L (b::a::R) := by
        simp [cfg,Tape.mk₂,Tape.mk',Tape.move]
      rw [ht,ih (a::R) b hb hL' xs (by simpa using hx)]
      simp [cfg,List.reverse_cons,List.append_assoc]
lemma finish_run (L : List Symbol) (hL : ∀ b∈L,b≠0)
    (xs : List Bool) (hx : xs.length=L.length+3) :
    execute xs (cfg (some 0) L [3])=cfg none [] (L.reverse++[3]) := by
  obtain ⟨ys,b,rfl⟩ : ∃ ys b,xs=ys++[b] := by
    have hn : xs.reverse≠[] := by
      intro h
      have h' : xs.length=0 := by simpa only [List.length_reverse,List.length_nil] using congrArg List.length h
      omega
    obtain ⟨b,ys,he⟩:=List.exists_cons_of_ne_nil hn
    exact ⟨ys.reverse,b,by have h:=congrArg List.reverse he; simpa using h⟩
  have hy : ys.length=L.length+2 := by simpa using hx
  have he : execute ys (cfg (some 0) L [3])=cfg (some 3) [] (L.reverse++[3]) := by
    have hr:=reset_run L [] 3 (by decide) hL ys hy
    cases ys with
    | nil => simp at hy
    | cons c ys =>
      rw [execute_cons] at hr ⊢
      have ht : tick machine (cfg (some 0) L [3]) c=tick machine (cfg (some 2) L [3]) c := by
        simp [tick,machine,Tape.mk₂,Tape.mk']
      rw [ht]
      exact hr
  rw [execute_append,he]
  simp [execute,tick,machine,cfg]

theorem execute_word (xs : List (Bool×Bool)) (tail : List Bool)
    (ht : tail.length=xs.length+3) :
    execute (pairCoins xs++tail) (cfg (some 0) [] (List.replicate xs.length 1++[3]))=
      cfg none [] (drawnWord xs++[3]) := by
  rw [execute_append,draw_forward,List.append_nil]
  have hn : ∀ b∈(drawnWord xs).reverse,b≠0 := by
    intro b hb
    obtain ⟨p,hp,rfl⟩:=List.mem_map.mp (List.mem_reverse.mp hb)
    exact bitSymbol_ne_zero _
  simpa using finish_run (drawnWord xs).reverse hn tail (by simpa [drawnWord] using ht)
end MatchingFPRAS.RandomWord

end OAI