import Mathlib
import OAI.Computability.VertexCover.Machines.Serialization
import OAI.Computability.VertexCover.Machines.TableBase
import OAI.Computability.VertexCover.Machines.FixedOps

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
open UniqueGames.Foundations.PCP

noncomputable def Poly.rawBooleans : Poly (listBits boolBits) id (id : List Bool → List Bool) := by
  let bit : Poly boolBits id (fun b => [b]) :=
    (Poly.identity boolBits).encodeCongr id (fun _ => rfl) (fun _ => rfl)
  exact ((Poly.listMap boolBits id false [] bit).comp Poly.rawFlatten).congr (fun xs => by induction xs with
    | nil => rfl
    | cons b bs ih => simpa only [Function.comp_apply,id_eq,List.map_cons,List.flatten_cons,List.singleton_append] using congrArg (List.cons b) ih)

noncomputable def Poly.vectorOfFn {α : Type} (ea : α → List Bool) (n : ℕ)
    (f : α → Fin n → Bool) (cf : ∀ i, Poly ea boolBits (fun a => f a i)) :
    Poly ea (fun v : Vector Bool n => v.toList) (fun a => Vector.ofFn (f a)) := by
  let c := (Poly.fixedList ea boolBits f cf (List.ofFn id)).comp Poly.rawBooleans
  exact c.encodeCongr id (fun _ => rfl) (fun a => by
    simp only [Function.comp_apply,id_eq,List.map_ofFn,Function.comp_def]
    apply List.ext_getElem
    · simp
    · intro i h₁ h₂; simp)

namespace GenericMachine
open GenericGraphTables
abbrev Row (q : ℕ) := (ℕ × ℕ) × RelationTable q
abbrev Data (q : ℕ) := ℕ × List (Row q)
def relationCode {q : ℕ} (r : RelationTable q) : List Bool := r.toList
def rowCode {q : ℕ} : Row q → List Bool := prodBits (prodBits natBits natBits) relationCode
def dataCode {q : ℕ} : Data q → List Bool := prodBits natBits (listBits rowCode)
def rowData {q n m : ℕ} (r : DartRow q n m) : Row q := ((r.tail.val,r.reverseIndex.val),r.relation)
def erase {q : ℕ} (T : Table q) : Data q := (T.vertices,T.rows.toList.map rowData)
def code {q : ℕ} (T : Table q) : List Bool := dataCode (erase T)
def relationDefault (q : ℕ) : RelationTable q := Vector.replicate (q*q) false
def rowDefault (q : ℕ) : Row q := ((0,0),relationDefault q)

noncomputable def verticesPoly {q : ℕ} : Poly (code (q := q)) natBits Table.vertices :=
  (Poly.fst natBits (listBits rowCode)).encodeCongr erase (fun _ => rfl) (fun _ => rfl)
noncomputable def rowsPoly {q : ℕ} : Poly (code (q := q)) (listBits rowCode) (fun T => T.rows.toList.map rowData) :=
  (Poly.snd natBits (listBits rowCode)).encodeCongr erase (fun _ => rfl) (fun _ => rfl)
noncomputable def dartsPoly {q : ℕ} : Poly (code (q := q)) natBits Table.darts :=
  ((rowsPoly (q := q)).comp (Poly.listLength rowCode (rowDefault q))).congr (fun T => by simp)
noncomputable def lookupPoly {q : ℕ} : Poly (prodBits (code (q := q)) natBits) rowCode
    (fun p : Table q × ℕ => (erase p.1).2.getD p.2 (rowDefault q)) := by
  let rows := (Poly.fst code natBits).comp (rowsPoly (q := q))
  let idx := Poly.snd (code (q := q)) natBits
  exact ((idx.pair rows).comp (Poly.listGetD rowCode (rowDefault q))).congr (fun _ => by
    simp only [Function.comp_apply,List.headD_eq_head?_getD,List.head?_drop,List.getD_eq_getElem?_getD]
    rfl)
 theorem lookup_valid {q : ℕ} (T : Table q) (i : Fin T.darts) :
    (erase T).2.getD i.val (rowDefault q) = rowData T.rows[i] := by
  simp only [erase,List.getD_eq_getElem?_getD,List.getElem?_map]
  rw [List.getElem?_eq_getElem (by simp)]
  rfl

 theorem materialize_source {α : Type} {q : ℕ} (Q : α → Table q) (r : α × ℕ → Row q)
    (hr : ∀ a (i : Fin (Q a).darts), r (a,i.val) = rowData (Q a).rows[i]) (a : α) :
    ((Q a).vertices,(List.range (Q a).darts).map (fun i => r (a,i))) = erase (Q a) := by
  apply Prod.ext
  · rfl
  apply List.ext_getElem
  · simp [erase]
  · intro i h₁ h₂
    simp only [erase,List.getElem_map,List.getElem_range,Vector.getElem_toList]
    exact hr a ⟨i,by simpa using h₁⟩
noncomputable def materializePoly {α : Type} (ea : α → List Bool) (a₀ : α) {q : ℕ}
    (Q : α → Table q) {r : α × ℕ → Row q}
    (cn : Poly ea natBits (fun a => (Q a).vertices))
    (cm : Poly ea natBits (fun a => (Q a).darts))
    (cr : Poly (prodBits ea natBits) rowCode r)
    (hr : ∀ a (i : Fin (Q a).darts), r (a,i.val) = rowData (Q a).rows[i]) :
    Poly ea code Q := by
  let rows := Poly.tabulate ea rowCode a₀ (rowDefault q) cm cr
  exact (cn.pair rows).encodeCongr id (fun _ => rfl) (fun a => by
    exact congrArg dataCode (materialize_source Q r hr a))
end GenericMachine

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