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

namespace OAI

namespace MatchingFPRAS.ZeroOutput
open Turing MachineCost

def program (s : Fin 3) : TM1.Stmt Symbol (Fin 3) Unit :=
  if s=0 then .move .left (.write (fun _ _=>6) (.move .right (.goto (fun _ _=>1))))
  else if s=1 then .branch (fun a _=>a==0) (.goto (fun _ _=>2))
    (.write (fun _ _=>0) (.move .right (.goto (fun _ _=>1))))
  else .branch (fun a _=>a==6)
    (.write (fun _ _=>0) (.move .right
      (.write (fun _ _=>4) (.move .right
      (.write (fun _ _=>3) (.move .right
      (.write (fun _ _=>2) (.move .right
      (.write (fun _ _=>3) (.move .left (.move .left (.move .left .halt))))))))))))
    (.move .left (.goto (fun _ _=>2)))
abbrev cfg (s : Option (Fin 3)) (L R : List Symbol) : TM1.Cfg Symbol (Fin 3) Unit :=
  ⟨s,(),Tape.mk₂ L R⟩
lemma zero_blank : ListBlank.mk [(0:Symbol)]=ListBlank.mk [] := by
  apply Quotient.sound
  exact Or.inr ⟨1,rfl⟩
lemma start (input : List Symbol) :
    advance (TM1.step program) (TM1.init input)=cfg (some 1) [6] input := by
  simp [advance,TM1.step,program,TM1.stepAux,TM1.init,cfg,Tape.mk₁,Tape.mk₂,Tape.mk',Tape.move,Tape.write]
lemma erase_step (a : Symbol) (L R : List Symbol) (ha : a≠0) :
    advance (TM1.step program) (cfg (some 1) L (a::R))=cfg (some 1) (0::L) R := by
  have hb : (a==0)=false := by simpa using ha
  simp [advance,TM1.step,program,TM1.stepAux,cfg,Tape.mk₂,Tape.mk',Tape.move,Tape.write,hb]
lemma erase_run (input : List Symbol) (L : List Symbol) (h : ∀ a∈input,a≠0) :
    MachineCost.run (TM1.step program) input.length (cfg (some 1) L input)=
      cfg (some 1) (List.replicate input.length 0++L) [] := by
  induction input generalizing L with
  | nil => rfl
  | cons a input ih =>
    have ha : a≠0:=h a (by simp)
    have hi : ∀ b∈input,b≠0:=fun b hb=>h b (by simp [hb])
    rw [List.length_cons,MachineCost.run,erase_step a L input ha,ih (0::L) hi]
    simp only [List.replicate_succ',List.append_assoc,List.singleton_append]
lemma switch (L : List Symbol) :
    advance (TM1.step program) (cfg (some 1) L [])=cfg (some 2) L [] := by
  simp [advance,TM1.step,program,TM1.stepAux,cfg,Tape.mk₂,Tape.mk']
lemma return_step (L : List Symbol) :
    advance (TM1.step program) (cfg (some 2) (0::L) [])=cfg (some 2) L [] := by
  simp [advance,TM1.step,program,TM1.stepAux,cfg,Tape.mk₂,Tape.mk',Tape.move]
  exact zero_blank
lemma return_run (n : ℕ) :
    MachineCost.run (TM1.step program) n (cfg (some 2) (List.replicate n 0++[6]) [])=
      cfg (some 2) [6] [] := by
  induction n with
  | zero => rfl
  | succ n ih =>
    rw [List.replicate_succ,List.cons_append,MachineCost.run,return_step,ih]
lemma return_finish :
    MachineCost.run (TM1.step program) 2 (cfg (some 2) [6] [])=
      cfg none [] (encodeRat 0) := by
  simp [MachineCost.run,advance,TM1.step,program,TM1.stepAux,cfg,Tape.mk₂,Tape.mk',Tape.move,Tape.write,
    encodeRat,encodeInt,encodeNat,Nat.bits]
  exact zero_blank

theorem run_zero (input : List Symbol) (h : ∀ a∈input,a≠0) :
    MachineCost.run (TM1.step program) (2*input.length+4) (TM1.init input)=
      cfg none [] (encodeRat 0) := by
  have heq : 2*input.length+4=1+input.length+1+(input.length+2) := by omega
  rw [heq,run_add _ (1+input.length+1) (input.length+2),run_add _ (1+input.length) 1,
    run_add _ 1 input.length]
  change MachineCost.run (TM1.step program) (input.length+2) (advance (TM1.step program)
    (MachineCost.run (TM1.step program) input.length (advance (TM1.step program) (TM1.init input)))) = _
  rw [start,erase_run input [6] h,switch,run_add,return_run,return_finish]
lemma cost_bound : programCost program ≤ 13 := by
  apply Finset.sup_le
  intro s _
  fin_cases s <;> decide

theorem post_zero (input : List Symbol) (h : ∀ a∈input,a≠0)
    (bits : Fin (26*input.length+54) → Bool) :
    Outputs (PostCompiler.compiled program) input bits 0 := by
  have he:=run_zero input h
  apply PostCompiler.compiled_outputs program input (2*input.length+4)
  · rw [he]
  · rw [he]
    exact Tape.mk'_right₀ _ _
  · calc
      programCost program*(2*input.length+4)+2 ≤ 13*(2*input.length+4)+2 :=
        Nat.add_le_add_right (Nat.mul_le_mul_right _ cost_bound) 2
      _ = 26*input.length+54 := by ring
lemma encodeNat_nonblank (n : ℕ) : ∀ a ∈ encodeNat n,a ≠ 0 := by
  intro a ha
  rcases List.mem_append.mp ha with ha | ha
  · obtain ⟨b,hb,rfl⟩:=List.mem_map.mp ha
    split <;> decide
  · simp only [List.mem_singleton] at ha
    subst a
    decide
lemma encodeInt_nonblank (z : ℤ) : ∀ a ∈ encodeInt z,a ≠ 0 := by
  intro a ha
  rcases List.mem_append.mp ha with ha | ha
  · split_ifs at ha <;> simp only [List.mem_singleton] at ha <;> subst a <;> decide
  · exact encodeNat_nonblank _ a ha
lemma encodeRat_nonblank (q : ℚ) : ∀ a ∈ encodeRat q,a ≠ 0 := by
  intro a ha
  rcases List.mem_append.mp ha with ha | ha
  · exact encodeInt_nonblank _ a ha
  · exact encodeNat_nonblank _ a ha
lemma encodeInput_nonblank (G : GraphInput) (ε δ : ℚ) :
    ∀ a ∈ encodeInput G ε δ,a ≠ 0 := by
  intro a ha
  simp only [encodeInput,List.mem_append] at ha
  rcases ha with (((ha|ha)|ha)|ha)|ha
  · exact encodeNat_nonblank _ a ha
  · exact encodeNat_nonblank _ a ha
  · obtain ⟨e,he,ha⟩:=List.mem_flatMap.mp ha
    rcases List.mem_append.mp ha with ha | ha
    · exact encodeNat_nonblank _ a ha
    · exact encodeNat_nonblank _ a ha
  · exact encodeRat_nonblank _ a ha
  · exact encodeRat_nonblank _ a ha

theorem post_zero_input (G : GraphInput) (ε δ : ℚ)
    (bits : Fin (26*(encodeInput G ε δ).length+54) → Bool) :
    Outputs (PostCompiler.compiled program) (encodeInput G ε δ) bits 0 :=
  post_zero _ (encodeInput_nonblank G ε δ) bits
end MatchingFPRAS.ZeroOutput

end OAI