File size: 6,259 Bytes
92416a2 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 | import Mathlib
import OAI.Computability.VertexCover.PCP.AlphabetRetraction
import OAI.Computability.VertexCover.PCP.RawInitialTables
import OAI.Computability.VertexCover.Machines.DenseParse
import OAI.Computability.VertexCover.Machines.TableBase
import OAI.Computability.VertexCover.Machines.FinCode
import OAI.Computability.VertexCover.Machines.Codec
import OAI.Computability.VertexCover.Machines.Cardinal
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
open PCP PCP.GraphTables
open FormulaParser TableMachine
namespace InitialTable
abbrev ClauseData := Triple (Bool × ℕ)
abbrev Signs := Triple Bool
def signsCode : Signs → List Bool := tripleCode boolBits
def clauseDefault : ClauseData := (((false,0),(false,0)),(false,0))
def signs (cs : ClauseData) : Signs := ((cs.1.1.1,cs.1.2.1),cs.2.1)
def lit (cs : ClauseData) (slot : Fin 3) : Bool × ℕ :=
if slot=0 then cs.1.1 else if slot=1 then cs.1.2 else cs.2
def accepts (s : Signs) (slot : Fin 3) (a b : InitialGraph.Label) : Bool :=
InitialGraph.variableValid b &&
(((PCP.literalValue s.1.1 a.1 || PCP.literalValue s.1.2 a.2.1) ||
PCP.literalValue s.2 a.2.2) &&
decide ((if slot=0 then a.1 else if slot=1 then a.2.1 else a.2.2) = b.1))
def relation (p : Signs × (Fin 3 × Bool)) : RelationTable :=
relationOf (fun a b =>
let x := AlphabetRetraction.decode64 (RawInitialTables.labelOrder.symm a)
let y := AlphabetRetraction.decode64 (RawInitialTables.labelOrder.symm b)
if p.2.2 then accepts p.1 p.2.1 y x else accepts p.1 p.2.1 x y)
def row (p : FormulaData × ℕ) : Row :=
let F := p.1
let i := p.2
let cs := F.2.getD (i/6) clauseDefault
let slot : Fin 3 := ⟨(i/2)%3,Nat.mod_lt _ (by decide)⟩
let flip := decide (i%2=1)
if i < 6*F.2.length then
((if flip then (lit cs slot).2 else F.1+i/6,
if flip then i-1 else i+1),relation (signs cs,(slot,flip)))
else ((F.1+F.2.length,6*F.2.length),relationOf (fun _ _ => true))
def output (F : FormulaData) : Data :=
(F.1+F.2.length+1,(List.range (6*F.2.length+1)).map (fun i => row (F,i)))
noncomputable def signsPoly : Poly unaryClauseCode signsCode signs := by
let ab := Poly.fst (prodBits unaryLiteralCode unaryLiteralCode) unaryLiteralCode
let a := (ab.comp (Poly.fst unaryLiteralCode unaryLiteralCode)).comp (Poly.fst boolBits natBits)
let b := (ab.comp (Poly.snd unaryLiteralCode unaryLiteralCode)).comp (Poly.fst boolBits natBits)
let c := (Poly.snd (prodBits unaryLiteralCode unaryLiteralCode) unaryLiteralCode).comp (Poly.fst boolBits natBits)
exact (a.pair b).pair c
noncomputable def litPoly : Poly (prodBits unaryClauseCode (finCode (n := 3))) unaryLiteralCode
(fun p : ClauseData × Fin 3 => lit p.1 p.2) := by
let cs := Poly.fst unaryClauseCode (finCode (n := 3))
let slot := Poly.snd unaryClauseCode (finCode (n := 3))
let test (i : Fin 3) := slot.comp (Poly.finite finCode boolBits (finCode_injective 3) (fun j => decide (j=i)))
let ab := cs.comp (Poly.fst (prodBits unaryLiteralCode unaryLiteralCode) unaryLiteralCode)
let a := ab.comp (Poly.fst unaryLiteralCode unaryLiteralCode)
let b := ab.comp (Poly.snd unaryLiteralCode unaryLiteralCode)
let c := cs.comp (Poly.snd (prodBits unaryLiteralCode unaryLiteralCode) unaryLiteralCode)
exact ((test 0).ite a ((test 1).ite b c)).congr (by intro p; simp only [Function.comp_apply,lit,decide_eq_true_eq])
noncomputable def relationPoly : Poly (prodBits signsCode (prodBits (finCode (n := 3)) boolBits))
relationCode relation :=
Poly.finite _ _ (prodBits_injective
(prodBits_injective (prodBits_injective boolBits_injective boolBits_injective) boolBits_injective)
(prodBits_injective (finCode_injective 3) boolBits_injective)) relation
noncomputable def rowPoly : Poly (prodBits FormulaParser.dataCode natBits) rowCode row := by
let enc := prodBits FormulaParser.dataCode natBits
let c (n : ℕ) := Poly.const enc natBits n
let F := Poly.fst FormulaParser.dataCode natBits
let i := Poly.snd FormulaParser.dataCode natBits
let n := F.comp (Poly.fst natBits (listBits unaryClauseCode))
let clauses := F.comp (Poly.snd natBits (listBits unaryClauseCode))
let len := clauses.comp (Poly.listLength unaryClauseCode clauseDefault)
let darts := ((c 6).pair len).comp Poly.natMul
let j := (i.pair (c 6)).comp Poly.natDiv
let cs := (j.pair clauses).comp (Poly.listGetD unaryClauseCode clauseDefault)
let slot := ((i.pair (c 2)).comp Poly.natDiv).comp (Poly.finMod 3 (by decide))
let flip := (((i.pair (c 2)).comp Poly.natMod).pair (c 1)).comp Poly.natBEq
let v := ((cs.pair slot).comp litPoly).comp (Poly.snd boolBits natBits)
let tail := flip.ite v ((n.pair j).comp Poly.natAdd)
let rev := flip.ite ((i.pair (c 1)).comp Poly.natSub) (i.comp Poly.natSucc)
let rel := ((cs.comp signsPoly).pair (slot.pair flip)).comp relationPoly
let normal := (tail.pair rev).pair rel
let dummy := (((n.pair len).comp Poly.natAdd).pair darts).pair
(Poly.const enc relationCode (relationOf (fun _ _ => true)))
let test := (i.pair darts).comp Poly.natLT
refine (test.ite normal dummy).congr ?_
intro p
simp only [Function.comp_apply,row,List.headD_eq_head?_getD,List.head?_drop,
List.getD_eq_getElem?_getD,decide_eq_true_eq]
noncomputable def outputPoly : Poly FormulaParser.dataCode TableMachine.dataCode output := by
let n := Poly.fst natBits (listBits unaryClauseCode)
let len := (Poly.snd natBits (listBits unaryClauseCode)).comp (Poly.listLength unaryClauseCode clauseDefault)
let darts := (((Poly.const FormulaParser.dataCode natBits 6).pair len).comp Poly.natMul).comp Poly.natSucc
let rows := Poly.tabulate FormulaParser.dataCode rowCode (0,[]) rowDefault darts rowPoly
exact (((n.pair len).comp Poly.natAdd).comp Poly.natSucc).pair rows
end InitialTable
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
|