import Mathlib
import OAI.Computability.VertexCover.Machines.TableBase
import OAI.Computability.VertexCover.Machines.FinCode

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

noncomputable def finiteCode (α : Type) [Fintype α] (a : α) : List Bool :=
  finCode (Fintype.equivFin α a)
theorem finiteCode_injective (α : Type) [Fintype α] : Function.Injective (finiteCode α) :=
  (finCode_injective _).comp (Fintype.equivFin α).injective

structure FixedLC (a b : ℕ) where
  u : ℕ
  v : ℕ
  M : ℕ
  apos : 0<a
  bpos : 0<b
  Mpos : 0<M
  left : Fin M → Fin u
  right : Fin M → Fin v
  projection : Fin M → Fin a → Fin b

namespace FixedLC
variable {a b : ℕ}
def toLC (I : FixedLC a b) : LabelCover where
  u := I.u
  v := I.v
  qU := a
  qV := b
  M := I.M
  qU_pos := I.apos
  qV_pos := I.bpos
  M_pos := I.Mpos
  left := I.left
  right := I.right
  projection := I.projection

def one (ha : 0<a) (hb : 0<b) : FixedLC a b where
  u := 1
  v := 1
  M := 1
  apos := ha
  bpos := hb
  Mpos := by decide
  left := fun _ => 0
  right := fun _ => 0
  projection := fun _ _ => ⟨0,hb⟩

abbrev Map (a b : ℕ) := Fin a → Fin b
abbrev Row (a b : ℕ) := (ℕ × ℕ) × Map a b
abbrev Data (a b : ℕ) := ℕ × (ℕ × List (Row a b))
noncomputable def mapCode : Map a b → List Bool := finiteCode (Map a b)
noncomputable def rowCode : Row a b → List Bool := prodBits (prodBits natBits natBits) mapCode
noncomputable def dataCode : Data a b → List Bool := prodBits natBits (prodBits natBits (listBits rowCode))
def data (I : FixedLC a b) : Data a b :=
  (I.u,(I.v,List.ofFn (fun e => ((I.left e |>.val,I.right e |>.val),I.projection e))))
noncomputable def code (I : FixedLC a b) : List Bool := dataCode I.data
def rowDefault (hb : 0<b) : Row a b := ((0,0),fun _ => ⟨0,hb⟩)
noncomputable def uPoly : Poly (code (a := a) (b := b)) natBits FixedLC.u :=
  (Poly.fst natBits (prodBits natBits (listBits rowCode))).encodeCongr data (fun _ => rfl) (fun _ => rfl)
noncomputable def restPoly : Poly (code (a := a) (b := b)) (prodBits natBits (listBits rowCode))
    (fun I => I.data.2) :=
  (Poly.snd natBits (prodBits natBits (listBits rowCode))).encodeCongr data (fun _ => rfl) (fun _ => rfl)
noncomputable def vPoly : Poly (code (a := a) (b := b)) natBits FixedLC.v :=
  restPoly.comp (Poly.fst natBits (listBits rowCode))
noncomputable def rowsPoly : Poly (code (a := a) (b := b)) (listBits rowCode) (fun I => I.data.2.2) :=
  restPoly.comp (Poly.snd natBits (listBits rowCode))
noncomputable def MPoly (hb : 0<b) : Poly (code (a := a) (b := b)) natBits FixedLC.M :=
  (rowsPoly.comp (Poly.listLength rowCode (rowDefault hb))).congr (fun I => by simp [data])
def lookup (hb : 0<b) (p : FixedLC a b × ℕ) : Row a b := p.1.data.2.2.getD p.2 (rowDefault hb)
noncomputable def lookupPoly (hb : 0<b) :
    Poly (prodBits (code (a := a) (b := b)) natBits) rowCode (lookup hb) :=
  (((Poly.snd code natBits).pair ((Poly.fst code natBits).comp rowsPoly)).comp
    (Poly.listGetD rowCode (rowDefault hb))).congr (fun _ => by
      simp only [Function.comp_apply,List.headD_eq_head?_getD,List.head?_drop]
      rfl)
 theorem lookup_valid (hb : 0<b) (I : FixedLC a b) (e : Fin I.M) :
    lookup hb (I,e.val) = ((I.left e |>.val,I.right e |>.val),I.projection e) := by
  simp only [lookup,data,List.getD_eq_getElem?_getD]
  rw [List.getElem?_eq_getElem (by simp)]
  simp
noncomputable def leftPoly (hb : 0<b) :
    Poly (prodBits (code (a := a) (b := b)) natBits) natBits (fun p => (lookup hb p).1.1) :=
  (lookupPoly hb).comp ((Poly.fst (prodBits natBits natBits) mapCode).comp (Poly.fst natBits natBits))
noncomputable def rightPoly (hb : 0<b) :
    Poly (prodBits (code (a := a) (b := b)) natBits) natBits (fun p => (lookup hb p).1.2) :=
  (lookupPoly hb).comp ((Poly.fst (prodBits natBits natBits) mapCode).comp (Poly.snd natBits natBits))
noncomputable def relationPoly (hb : 0<b) :
    Poly (prodBits (code (a := a) (b := b)) natBits) mapCode (fun p => (lookup hb p).2) :=
  (lookupPoly hb).comp (Poly.snd (prodBits natBits natBits) mapCode)

noncomputable def materializePoly {α : Type} (ea : α → List Bool) (a₀ : α)
    (Q : α → FixedLC a b) (hb : 0<b) {r : α × ℕ → Row a b}
    (cu : Poly ea natBits (fun x => (Q x).u))
    (cv : Poly ea natBits (fun x => (Q x).v))
    (cm : Poly ea natBits (fun x => (Q x).M))
    (cr : Poly (prodBits ea natBits) rowCode r)
    (hr : ∀ x (e : Fin (Q x).M), r (x,e.val) = (((Q x).left e |>.val,(Q x).right e |>.val),(Q x).projection e)) :
    Poly ea code Q := by
  let rows := Poly.tabulate ea rowCode a₀ (rowDefault hb) cm cr
  have he (x : α) : (List.range (Q x).M).map (fun e => r (x,e)) = (Q x).data.2.2 := by
    apply List.ext_getElem
    · simp [data]
    · intro i hi hj
      simp only [List.getElem_map,List.getElem_range,data,List.getElem_ofFn]
      exact hr x ⟨i,by simpa using hi⟩
  exact (cu.pair (cv.pair rows)).encodeCongr id (fun _ => rfl) (fun x => by
    change dataCode ((Q x).u,((Q x).v,_)) = dataCode (data (Q x))
    rw [he]
    rfl)
end FixedLC
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