import Mathlib
import OAI.Computability.VertexCover.Machines.Option
import OAI.Computability.VertexCover.Machines.BoundedBinary
import OAI.Computability.VertexCover.Machines.ParseName
import OAI.Computability.VertexCover.Machines.ParseSize

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.BinaryEncoding

def firstName (bs : List Bool) : ℕ := ((parseName bs).getD (0,[])).1

noncomputable def firstNamePoly : Poly id Nat.bits firstName :=
  (NameParser.poly.comp (Poly.getD (prodBits Nat.bits id) (0,[]))).comp (Poly.fst Nat.bits id)

noncomputable def boundedFirstNamePoly : Poly id natBits (fun bs => min bs.length (firstName bs)) := by
  let digits : Poly id id (fun bs => (firstName bs).bits) :=
    firstNamePoly.encodeCongr id (fun _ => rfl) (fun _ => rfl)
  exact ((FormulaParser.rawLength.pair digits).comp Poly.decodeBounded).congr (fun bs => by
    simp only [Function.comp_apply,bitsValue_bits])

theorem firstName_encoded (n : ℕ) (rest : List Bool) :
    firstName (nameBits n++rest) = n := by simp [firstName]

theorem names_length (ns : List ℕ) : ns.length ≤ (ns.flatMap nameBits).length := by
  induction ns with
  | nil => rfl
  | cons n ns ih =>
    simp only [List.flatMap_cons,List.length_append,List.length_cons,nameBits_length]
    omega

theorem firstName_graph (G : ExplicitGraph) : firstName G.bits = G.n := by
  simp only [ExplicitGraph.bits,List.singleton_append]
  exact firstName_encoded _ _

theorem graph_card_le_bits (G : ExplicitGraph) : G.n ≤ G.bits.length := by
  have h := names_length ([G.n] ++ List.range G.n ++ [G.edges.length] ++
    G.edges.flatMap (fun e => [e.1.val,e.2.val]))
  simp only [List.length_append,List.length_cons,List.length_nil,List.length_range] at h
  exact (by omega : G.n ≤ 1+G.n+1+(G.edges.flatMap (fun e => [e.1.val,e.2.val])).length).trans h

noncomputable def Poly.graphCard : Poly ExplicitGraph.bits natBits (fun G => G.n) :=
  boundedFirstNamePoly.encodeCongr ExplicitGraph.bits (fun _ => rfl) (fun G => by
    rw [firstName_graph,Nat.min_eq_right (graph_card_le_bits G)])

theorem firstName_list (xs : List ℕ) : firstName (natListBits xs) = xs.length := by
  exact firstName_encoded _ _

theorem natList_length_le_bits (xs : List ℕ) : xs.length ≤ (natListBits xs).length := by
  exact (Nat.le_succ _).trans (names_length (xs.length::xs))

noncomputable def Poly.natListCard : Poly natListBits natBits (List.length : List ℕ → ℕ) :=
  boundedFirstNamePoly.encodeCongr natListBits (fun _ => rfl) (fun xs => by
    rw [firstName_list,Nat.min_eq_right (natList_length_le_bits xs)])

noncomputable def Poly.natLT : Poly (prodBits natBits natBits) boolBits
    (fun p : ℕ × ℕ => decide (p.1<p.2)) :=
  ((((Poly.fst natBits natBits).comp Poly.natSucc).pair (Poly.snd natBits natBits)).comp
    Poly.natLE).congr (fun p => by simp only [Function.comp_apply,Nat.succ_le_iff])

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