| import Mathlib |
| import OAI.Computability.VertexCover.Machines.NatDiv |
| import OAI.Computability.VertexCover.Machines.TableBase |
|
|
| 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 |
|
|
| namespace ExpandMachine |
|
|
| abbrev Input (q : ℕ) := Σ v, ExpanderTables.Table v q |
| abbrev Data := ℕ × List ℕ |
| def dataCode : Data → List Bool := prodBits natBits (listBits natBits) |
| def erase {q : ℕ} (T : Input q) : Data := (T.1,T.2.rows.toList.map Fin.val) |
| def code {q : ℕ} (T : Input q) : List Bool := dataCode (erase T) |
|
|
| def lookup (q : ℕ) (p : List ℕ × (ℕ × ℕ)) : ℕ × ℕ := |
| let r := p.1.getD (p.2.2+q*p.2.1) 0 |
| (r/q,r%q) |
|
|
| noncomputable def lookupPoly (q : ℕ) : |
| Poly (prodBits (listBits natBits) (prodBits natBits natBits)) (prodBits natBits natBits) (lookup q) := by |
| let e := prodBits (listBits natBits) (prodBits natBits natBits) |
| let rows := Poly.fst (listBits natBits) (prodBits natBits natBits) |
| let x := Poly.snd (listBits natBits) (prodBits natBits natBits) |
| let v := x.comp (Poly.fst natBits natBits) |
| let port := x.comp (Poly.snd natBits natBits) |
| let base := ((Poly.const e natBits q).pair v).comp Poly.natMul |
| let idx := (port.pair base).comp Poly.natAdd |
| let r := (idx.pair rows).comp (Poly.listGetD natBits 0) |
| let qp := r.pair (Poly.const e natBits q) |
| exact ((qp.comp Poly.natDiv).pair (qp.comp Poly.natMod)).congr (fun _ => by |
| simp only [Function.comp_apply,lookup,List.headD_eq_head?_getD,List.head?_drop,List.getD_eq_getElem?_getD]) |
|
|
| theorem lookup_erase {q v : ℕ} (T : ExpanderTables.Table v q) (x : Fin v × Fin q) : |
| lookup q (T.rows.toList.map Fin.val,(x.1.val,x.2.val)) = |
| ((ExpanderTables.lookup T x).1.val,(ExpanderTables.lookup T x).2.val) := by |
| have hi : x.2.val+q*x.1.val < (T.rows.toList.map Fin.val).length := by |
| simp only [List.length_map,Vector.length_toList] |
| exact (ExpanderTables.rowIndex v q x).isLt |
| rw [lookup,List.getD_eq_getElem _ _ hi,List.getElem_map] |
| rfl |
|
|
| def stepRow (d : ℕ) (H : List ℕ) (p : Data × ℕ) : ℕ := |
| let D := d*d |
| let g := D*D |
| let x := p.2/D |
| let port := p.2%D |
| let first := lookup d (H,(x%g,port/d)) |
| let outerFirst := lookup D (p.1.2,(x/g,first.1/D)) |
| let outerSecond := lookup D (p.1.2,(outerFirst.1,first.1%D)) |
| let last := lookup d (H,(outerFirst.2+D*outerSecond.2,port%d)) |
| (first.2+d*last.2)+D*(last.1+g*outerSecond.1) |
|
|
| def stepData (d : ℕ) (H : List ℕ) (T : Data) : Data := |
| let v := T.1*((d*d)*(d*d)) |
| (v,(List.range (v*(d*d))).map (fun i => stepRow d H (T,i))) |
|
|
| noncomputable def stepRowPoly (d : ℕ) (H : List ℕ) : |
| Poly (prodBits dataCode natBits) natBits (stepRow d H) := by |
| let e := prodBits dataCode natBits |
| let D := d*d |
| let g := D*D |
| let c (n : ℕ) := Poly.const e natBits n |
| let T := Poly.fst dataCode natBits |
| let rows := T.comp (Poly.snd natBits (listBits natBits)) |
| let i := Poly.snd dataCode natBits |
| let x := (i.pair (c D)).comp Poly.natDiv |
| let port := (i.pair (c D)).comp Poly.natMod |
| let Hc := Poly.const e (listBits natBits) H |
| let first := (Hc.pair (((x.pair (c g)).comp Poly.natMod).pair |
| ((port.pair (c d)).comp Poly.natDiv))).comp (lookupPoly d) |
| let firstV := first.comp (Poly.fst natBits natBits) |
| let firstP := first.comp (Poly.snd natBits natBits) |
| let out₁ := (rows.pair (((x.pair (c g)).comp Poly.natDiv).pair |
| ((firstV.pair (c D)).comp Poly.natDiv))).comp (lookupPoly D) |
| let out₁V := out₁.comp (Poly.fst natBits natBits) |
| let out₁P := out₁.comp (Poly.snd natBits natBits) |
| let out₂ := (rows.pair (out₁V.pair ((firstV.pair (c D)).comp Poly.natMod))).comp (lookupPoly D) |
| let out₂V := out₂.comp (Poly.fst natBits natBits) |
| let out₂P := out₂.comp (Poly.snd natBits natBits) |
| let lastV := (out₁P.pair (((c D).pair out₂P).comp Poly.natMul)).comp Poly.natAdd |
| let last := (Hc.pair (lastV.pair ((port.pair (c d)).comp Poly.natMod))).comp (lookupPoly d) |
| let v := ((last.comp (Poly.fst natBits natBits)).pair |
| (((c g).pair out₂V).comp Poly.natMul)).comp Poly.natAdd |
| let p := (firstP.pair (((c d).pair (last.comp (Poly.snd natBits natBits))).comp Poly.natMul)).comp Poly.natAdd |
| exact (p.pair (((c D).pair v).comp Poly.natMul)).comp Poly.natAdd |
|
|
| noncomputable def stepDataPoly (d : ℕ) (H : List ℕ) : Poly dataCode dataCode (stepData d H) := by |
| let v := ((Poly.fst natBits (listBits natBits)).pair |
| (Poly.const dataCode natBits ((d*d)*(d*d)))).comp Poly.natMul |
| let len := (v.pair (Poly.const dataCode natBits (d*d))).comp Poly.natMul |
| exact v.pair (Poly.tabulate dataCode natBits (0,[]) 0 len (stepRowPoly d H)) |
|
|
| end ExpandMachine |
| 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 |
|
|
