import Mathlib
import OAI.Computability.VertexCover.Machines.GraphNumber
import OAI.Computability.VertexCover.Machines.BinaryOutput

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.GraphMachine
open LabelCover
noncomputable section
variable {a b d : ℕ}

def candidates (I : FixedLC a b) (d : ℕ) : List (ℕ × ℕ) :=
  (List.range (count I d * count I d)).map (fun i => (i/count I d,i%count I d))
def edgeValues (I : FixedLC a b) (d : ℕ) (t : ℝ) : List (ℕ × ℕ) :=
  (candidates I d).filter (fun p => test (d := d) t (I,p))

theorem candidates_eq (I : FixedLC a b) (d : ℕ) :
    candidates I d = (List.ofFn fun e : Fin (count I d * count I d) => finProdFinEquiv.symm e).map
      (fun p => (p.1.val,p.2.val)) := by
  apply List.ext_getElem
  · simp [candidates]
  · intro i hi hj
    simp only [candidates,List.getElem_map,List.getElem_range,List.getElem_ofFn]
    rfl

theorem edgeValues_eq (I : FixedLC a b) (d : ℕ) (t : ℝ) :
    edgeValues I d t=(explicitGraph I d t).edges.map (fun p => (p.1.val,p.2.val)) := by
  classical
  rw [edgeValues,candidates_eq,List.filter_map]
  change List.map _ (List.filter _ _) = List.map _ (List.filter _ _)
  congr 1
  apply List.filter_congr
  intro p hp
  apply Bool.eq_iff_iff.mpr
  exact (test_correct I t p.1 p.2).trans decide_eq_true_iff.symm

def candidatesPoly (ha : 0<a) (hb : 0<b) (d : ℕ) :
    Poly (FixedLC.code (a := a) (b := b)) (listBits (prodBits natBits natBits)) (fun I => candidates I d) := by
  let c := countPoly (a := a) hb d
  let n := (c.pair c).comp Poly.natMul
  let count := (Poly.fst (FixedLC.code (a := a) (b := b)) natBits).comp c
  let i := Poly.snd (FixedLC.code (a := a) (b := b)) natBits
  let pair := ((i.pair count).comp Poly.natDiv).pair ((i.pair count).comp Poly.natMod)
  exact Poly.tabulate FixedLC.code (prodBits natBits natBits) (FixedLC.one ha hb) (0,0) n pair

def edgeValuesPoly (ha : 0<a) (hb : 0<b) (d : ℕ) (t : ℝ) :
    Poly (FixedLC.code (a := a) (b := b)) (listBits (prodBits natBits natBits)) (fun I => edgeValues I d t) :=
  (((Poly.identity FixedLC.code).pair (candidatesPoly ha hb d)).comp
    (Poly.listFilterWith FixedLC.code (prodBits natBits natBits) (FixedLC.one ha hb) (0,0)
      (testPoly (d := d) ha hb t))).congr (fun _ => rfl)

def endpointPoly : Poly (prodBits natBits natBits) (listBits natBits) (fun p : ℕ × ℕ => [p.1,p.2]) :=
  (((Poly.fst natBits natBits).pair ((Poly.snd natBits natBits).comp (Poly.listSingleton natBits))).comp
    (Poly.listCons natBits)).congr (fun _ => rfl)
def names (I : FixedLC a b) (d : ℕ) (t : ℝ) : List ℕ :=
  [count I d] ++ List.range (count I d) ++ [(edgeValues I d t).length] ++
    (edgeValues I d t).flatMap (fun p => [p.1,p.2])
def namesPoly (ha : 0<a) (hb : 0<b) (d : ℕ) (t : ℝ) :
    Poly (FixedLC.code (a := a) (b := b)) (listBits natBits) (fun I => names I d t) := by
  let n := countPoly (a := a) hb d
  let head := n.comp (Poly.listSingleton natBits)
  let verts := n.comp Poly.range
  let es := edgeValuesPoly ha hb d t
  let ne := ((es.comp (Poly.listLength (prodBits natBits natBits) (0,0))).comp (Poly.listSingleton natBits))
  let ends := es.comp (Poly.listFlatMap (prodBits natBits natBits) natBits (0,0) 0 endpointPoly)
  let one := (head.pair verts).comp (Poly.listAppend natBits 0)
  let two := (one.pair ne).comp (Poly.listAppend natBits 0)
  exact ((two.pair ends).comp (Poly.listAppend natBits 0)).congr (fun _ => rfl)

theorem names_bits (I : FixedLC a b) (d : ℕ) (t : ℝ) :
    (names I d t).flatMap UniqueGames.BinaryEncoding.nameBits = (explicitGraph I d t).bits := by
  rw [names,edgeValues_eq]
  simp only [List.length_map,List.flatMap_map]
  rfl

def outputPoly (ha : 0<a) (hb : 0<b) (d : ℕ) (t : ℝ) :
    Poly (FixedLC.code (a := a) (b := b)) ExplicitGraph.bits (fun I => explicitGraph I d t) :=
  ((namesPoly ha hb d t).comp Poly.nameList).encodeCongr id (fun _ => rfl) (fun I => names_bits I d t)
end
end VertexCover.Machine.GraphMachine
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