| import Mathlib |
| import OAI.Computability.QuantumFactoring.AIGNetworkEmission |
|
|
| namespace OAI |
|
|
|
|
|
|
| section |
|
|
| namespace ExactQuantumFactoring.AIGNetworkEmission |
| open BitStackProgram BitStackProgram.Procedure NetworkEmission |
| open NetworkEmission.Emission |
| namespace Emission |
| abbrev dimsCode:=prodCode unaryCode unaryCode |
| noncomputable def faninPackP : Procedure (prodCode dimsCode NativeAIG.refCode) packCode |
| (fun x=>faninPack x.1.1 x.1.2 x.2):=by |
| let e:=first dimsCode NativeAIG.refCode |
| let n:=(first unaryCode unaryCode).comp e |
| let gs:=(second unaryCode unaryCode).comp e |
| let w:=unaryAdd.comp (n.pair gs) |
| let ref:=second dimsCode NativeAIG.refCode |
| let idx:=(first Nat.bits boolCode).comp ref |
| let inv:=(second Nat.bits boolCode).comp ref |
| let off:=binaryAdd.comp ((unaryToBits.comp n).pair idx) |
| let v:=conditional (binaryLt.comp (idx.pair (unaryToBits.comp gs))) |
| (bitPackP.comp (w.pair off)) (constantPackP.comp (w.pair (Procedure.constant _ boolCode false))) |
| exact (conditional inv (bnotPackP.comp v) v).congrFun (by intro x |
|
|
| def declTag : NativeAIG.Decl→ℕ | .zero=>0 | .atom _=>1 | .gate _ _=>2 |
| def declAtom : NativeAIG.Decl→ℕ | .atom i=>i | _=>0 |
| def declGate : NativeAIG.Decl→NativeAIG.Key | .gate a b=>(a,b) | _=>((0,false),(0,false)) |
| noncomputable def declTagP : Procedure NativeAIG.declCode Nat.bits declTag:= |
| ((casesSum (Procedure.constant emptyCode Nat.bits 0) |
| (casesSum (Procedure.constant Nat.bits Nat.bits 1) (Procedure.constant NativeAIG.keyCode Nat.bits 2))).precompose |
| NativeAIG.declView).congrFun (by intro d |
| noncomputable def declAtomP : Procedure NativeAIG.declCode Nat.bits declAtom:= |
| ((casesSum (Procedure.constant emptyCode Nat.bits 0) |
| (casesSum (identity Nat.bits) (Procedure.constant NativeAIG.keyCode Nat.bits 0))).precompose |
| NativeAIG.declView).congrFun (by intro d |
| noncomputable def declGateP : Procedure NativeAIG.declCode NativeAIG.keyCode declGate:= |
| ((casesSum (Procedure.constant emptyCode NativeAIG.keyCode ((0,false),(0,false))) |
| (casesSum (Procedure.constant Nat.bits NativeAIG.keyCode ((0,false),(0,false))) (identity NativeAIG.keyCode))).precompose |
| NativeAIG.declView).congrFun (by intro d |
| noncomputable def nodePackP : Procedure (prodCode dimsCode NativeAIG.declCode) packCode |
| (fun x=>nodePack x.1.1 x.1.2 x.2):=by |
| let e:=first dimsCode NativeAIG.declCode |
| let w:=unaryAdd.comp e |
| let d:=second dimsCode NativeAIG.declCode |
| let tag:=declTagP.comp d |
| let z:=constantPackP.comp (w.pair (Procedure.constant _ boolCode false)) |
| let a:=bitPackP.comp (w.pair (declAtomP.comp d)) |
| let l:=(first NativeAIG.refCode NativeAIG.refCode).comp (declGateP.comp d) |
| let r:=(second NativeAIG.refCode NativeAIG.refCode).comp (declGateP.comp d) |
| let g:=bandPackP.comp ((faninPackP.comp (e.pair l)).pair (faninPackP.comp (e.pair r))) |
| exact (conditional (binaryEq.comp (tag.pair (Procedure.constant _ Nat.bits 0))) z |
| (conditional (binaryEq.comp (tag.pair (Procedure.constant _ Nat.bits 1))) a g)).congrFun (by |
| rintro ⟨e,d⟩ |
|
|
| abbrev graphInputCode:=prodCode unaryCode (listCode NativeAIG.declCode) |
| noncomputable def partialPackP : Procedure (prodCode graphInputCode unaryCode) packCode |
| (fun x=>partialPack x.1.1 x.1.2 x.2):=by |
| let e:=second unaryCode graphInputCode |
| let n:=(first unaryCode (listCode NativeAIG.declCode)).comp e |
| let ds:=(second unaryCode (listCode NativeAIG.declCode)).comp e |
| let gs:=(NativeAIG.Emission.listUnaryLength NativeAIG.declCode .zero).comp ds |
| let w:=unaryAdd.comp (n.pair gs) |
| let i:=first unaryCode graphInputCode |
| let off:=binaryAdd.comp ((unaryToBits.comp n).pair (unaryToBits.comp i)) |
| let d:=(listGet NativeAIG.declCode .zero).comp ((unaryToBits.comp i).pair ds) |
| let node:=nodePackP.comp ((n.pair gs).pair d) |
| let step:=assignPackP.comp (w.pair (off.pair node)) |
| let input:=first graphInputCode unaryCode |
| let num:=second graphInputCode unaryCode |
| let parts:=(tabulate (f:=fun (x:ℕ×List NativeAIG.Decl) i=>assignPack (x.1+x.2.length) (x.1+i) |
| (nodePack x.1 x.2.length ((x.2.drop i).headD .zero))) emptyPack step).comp (num.pair input) |
| let nn:=(first unaryCode (listCode NativeAIG.declCode)).comp input |
| let gg:=(NativeAIG.Emission.listUnaryLength NativeAIG.declCode .zero).comp ((second unaryCode (listCode NativeAIG.declCode)).comp input) |
| exact foldCompP.comp (parts.pair (identityPackP.comp (unaryAdd.comp (nn.pair gg)))) |
| noncomputable def padPackP : Procedure dimsCode packCode (fun x=>padPack x.1 x.2):=by |
| let e:=second unaryCode dimsCode |
| let n:=(first unaryCode unaryCode).comp e |
| let i:=unaryToBits.comp (first unaryCode dimsCode) |
| let v:=conditional (binaryLt.comp (i.pair (unaryToBits.comp n))) |
| (bitPackP.comp (n.pair i)) (constantPackP.comp (n.pair (Procedure.constant _ boolCode false))) |
| let parts:=(tabulate (f:=fun (x:ℕ×ℕ) i=>if i<x.1 then bitPack x.1 i else constantPack x.1 false) |
| emptyPack (v.congrFun (by intro x |
| exact vectorPackP.comp ((first unaryCode unaryCode).pair parts) |
| noncomputable def compilePackP : Procedure (prodCode graphInputCode (listCode NativeAIG.refCode)) packCode |
| (fun x=>compilePack x.1.1 x.1.2 x.2):=by |
| let e:=first graphInputCode (listCode NativeAIG.refCode) |
| let n:=(first unaryCode (listCode NativeAIG.declCode)).comp e |
| let ds:=(second unaryCode (listCode NativeAIG.declCode)).comp e |
| let gs:=(NativeAIG.Emission.listUnaryLength NativeAIG.declCode .zero).comp ds |
| let dim:=n.pair gs |
| let pad:=padPackP.comp dim |
| let graph:=partialPackP.comp (e.pair gs) |
| let refs:=second graphInputCode (listCode NativeAIG.refCode) |
| let parts:=(listMapWith (f:=fun (x:ℕ×ℕ) f=>faninPack x.1 x.2 f) (0,false) emptyPack faninPackP).comp (dim.pair refs) |
| let output:=vectorPackP.comp ((unaryAdd.comp dim).pair parts) |
| exact compPackP.comp ((compPackP.comp (pad.pair graph)).pair output) |
| end Emission |
| end ExactQuantumFactoring.AIGNetworkEmission |
|
|
| end |
|
|
|
|
|
|
| end OAI |
|
|
