import Mathlib
import OAI.Computability.VertexCover.Machines.ListFilter
import OAI.Computability.VertexCover.Machines.Generic

namespace OAI

section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
section
                                 
section

namespace VertexCover.Machine
namespace BinaryOutput
abbrev State := ℕ × List Bool
abbrev enc : State → List Bool := prodBits natBits id
def body (p : State) : Bool × State :=
  if p.1=0 then (false,p) else (true,(p.1/2,decide (p.1%2=1)::p.2))
def result (p : State) : State := (0,p.1.bits.reverse++p.2)
noncomputable def bodyPoly : Poly enc (flagBits enc) body := by
  let n := Poly.fst natBits (id : List Bool → List Bool)
  let bs := Poly.snd natBits (id : List Bool → List Bool)
  let test := n.comp Poly.natZero
  let bit := (((n.pair (Poly.const enc natBits 2)).comp Poly.natMod).pair
    (Poly.const enc natBits 1)).comp Poly.natEq
  let out := bit.ite (bs.comp (Poly.cons true)) (bs.comp (Poly.cons false))
  let next := ((n.pair (Poly.const enc natBits 2)).comp Poly.natDiv).pair out
  exact ((test.comp (Poly.bool Bool.not)).flagPair (test.ite (Poly.identity enc) next)).congr
    (fun p => by
      by_cases h : p.1=0
      · simp [Function.comp_apply,body,h]
      · simp only [Function.comp_apply,body,h,ite_false,decide_false,Bool.not_false]
        congr 2
        by_cases hb : p.1%2=1 <;> simp [hb])
 theorem bits_step (n : ℕ) (hn : n≠0) : n.bits=decide (n%2=1)::(n/2).bits := by
  have he : Nat.bit (decide (n%2=1)) (n/2)=n := by
    have hm := Nat.mod_lt n (by decide : 0<2)
    have hv := Nat.mod_add_div n 2
    by_cases h : n%2=1 <;> simp [Nat.bit,h] <;> omega
  conv_lhs => rw [← he]
  rw [Nat.bits_append_bit _ _ (by
    intro hz
    by_contra hb
    have hh : decide (n%2=1)=false := by cases h : decide (n%2=1) <;> simp_all
    rw [hh,hz] at he
    exact hn he.symm)]
 theorem run (n : ℕ) (xs : List Bool) (B : ℕ) (hsize : (enc (n,xs)).length ≤ B) :
    ∃ k, k≤n+1 ∧ BoundedRun enc body B (n,xs) (result (n,xs)) k := by
  induction n using Nat.strong_induction_on generalizing xs with
  | h n ih =>
    by_cases hn : n=0
    · subst n
      refine ⟨1,le_rfl,?_⟩
      simpa [body,result] using
        (BoundedRun.stop (e := enc) (body := body) (0,xs) hsize (by simp [body]))
    · have hlt := Nat.div_lt_self (Nat.pos_of_ne_zero hn) (by decide : 1<2)
      have hs : (enc (n/2,decide (n%2=1)::xs)).length ≤ B := by
        simp only [enc,prodBits,pairBits_length,natBits_length,id_eq,List.length_cons] at hsize ⊢
        omega
      obtain ⟨k,hk,hr⟩ := ih (n/2) hlt _ hs
      have he : result (n/2,decide (n%2=1)::xs)=result (n,xs) := by
        simp only [result,bits_step n hn,List.reverse_cons,List.append_assoc,List.singleton_append]
      rw [he] at hr
      refine ⟨k+1,by omega,.next _ _ k hsize (by simp [body,hn]) ?_⟩
      simpa only [body,hn,ite_false] using hr
noncomputable def poly : Poly enc enc result :=
  bodyPoly.loop result Polynomial.X (Polynomial.X+1) (by
    intro ⟨n,xs⟩
    obtain ⟨k,hk,hr⟩ := run n xs (enc (n,xs)).length le_rfl
    refine ⟨k,?_,by simpa only [Polynomial.eval_X] using hr⟩
    simp only [Polynomial.eval_add,Polynomial.eval_X,Polynomial.eval_one,
      enc,prodBits,pairBits_length,natBits_length,id_eq]
    omega)
end BinaryOutput
noncomputable def Poly.rawReverse : Poly id id (List.reverse : List Bool → List Bool) :=
  ((Poly.rawToList.comp (Poly.listReverse boolBits false)).comp Poly.rawBooleans).congr (fun _ => rfl)
noncomputable def Poly.binaryDigits : Poly natBits id Nat.bits :=
  (((((Poly.identity natBits).pair (Poly.const natBits id ([] : List Bool))).comp BinaryOutput.poly).comp
    (Poly.snd natBits (id : List Bool → List Bool))).comp Poly.rawReverse).congr
      (fun n => by simp only [Function.comp_apply,BinaryOutput.result,List.append_nil,List.reverse_reverse,id_eq])
noncomputable def Poly.binaryFrame : Poly id id UniqueGames.BinaryEncoding.frame := by
  let δ : Unit → Bool → Unit × List Bool := fun _ b => ((),[true,b])
  have h (q : Unit) (bs : List Bool) : Stream.output δ (fun _ => [false]) q bs = UniqueGames.BinaryEncoding.frame bs := by
    induction bs generalizing q with
    | nil => rfl
    | cons b bs ih => simp only [Stream.output,δ,List.cons_append,List.nil_append,ih,UniqueGames.BinaryEncoding.frame]
  exact (Stream.poly () δ (fun _ => [false]) 2 (by simp [δ]) (by simp)).congr (fun bs => h () bs)
noncomputable def Poly.nameBits : Poly natBits id UniqueGames.BinaryEncoding.nameBits :=
  Poly.binaryDigits.comp Poly.binaryFrame
noncomputable def Poly.nameList : Poly (listBits natBits) id
    (fun xs => xs.flatMap UniqueGames.BinaryEncoding.nameBits) :=
  ((Poly.listMap natBits id 0 [] Poly.nameBits).comp Poly.rawFlatten).congr (fun xs => by
    simp only [Function.comp_apply]
    induction xs with
    | nil => rfl
    | cons a xs ih => simp only [List.map_cons,List.flatten_cons,List.flatMap_cons,ih])
end VertexCover.Machine
end


end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end
end

end OAI