| import OAI.Computability.SpaceSimulation.Evaluation.Local |
| import OAI.Computability.SpaceSimulation.Register.Flow |
|
|
| namespace OAI |
|
|
| /-! |
| A specialized evaluator supporting the simulation's factored and ordinary |
| gates. Can treat the latter as special factored gates by allowing the |
| selector/test function at a coordinate z to depend on z, *including* |
| the extra coordinate d of augmented words. |
| -/ |
| namespace Fifths |
|
|
| structure Circuit where |
| width : ℕ |
| count : ℕ |
| nodes : ℕ |
| base : Fin nodes → Bool |
| |
| head : Fin nodes → Fin nodes |
| child : Fin nodes → ℕ → Fin nodes |
| guessing : Fin nodes → ℕ |
| first : Fin nodes → ℕ |
| / |
| propose : Fin nodes → ℕ → ℕ → ℕ → ℕ |
| / |
| allows : Fin nodes → ℕ → ℕ → ℕ → ℕ → ℕ → ℕ |
| semantic : Fin nodes → ℕ |
|
|
| abbrev Slot := Fin 3 |
| namespace Slot |
| @[simp] def H (j : Slot) := j+1 |
| @[simp] def A (j : Slot) := j+2 |
| @[simp] theorem h_ne (j : Slot) : H j ≠ j := by fin_cases j <;> decide |
| @[simp] theorem a_ne (j : Slot) : A j ≠ j := by fin_cases j <;> decide |
| @[simp] theorem sep (j : Slot) : H j ≠ A j := by fin_cases j <;> decide |
| end Slot |
|
|
| namespace Modulus |
| variable (P : Modulus) |
|
|
| abbrev Pool := Slot → P.Vec |
|
|
| def plus (R : P.Pool) (t : Slot) (v : P.Vec) : P.Pool := |
| fun j i => if j=t then R j i + v i else R j i |
| def multiple (b : P.K) (v : P.Vec) : P.Vec := fun i => b * v i |
| def spike (b : P.K) (z : ℕ) : P.Vec := fun i => if i=z then b else 0 |
|
|
| theorem plus_at (R : P.Pool) (t : Slot) (v : P.Vec) : |
| P.plus R t v t = fun i => R t i + v i := by funext i; simp [plus] |
|
|
| theorem plus_other (R : P.Pool) {t j : Slot} (v : P.Vec) (h : j ≠ t) : |
| P.plus R t v j = R j := by funext i; simp [plus,h] |
| theorem plus_zero (R : P.Pool) (t : Slot) : |
| P.plus R t (fun _ => 0) = R := by |
| ext j i |
| simp [plus] |
|
|
| theorem plus_twice (R : P.Pool) (t : Slot) (v w : P.Vec) : |
| P.plus (P.plus R t v) t w = P.plus R t (fun i => v i + w i) := by |
| ext j i |
| by_cases h : j = t <;> simp [plus,h,add_assoc] |
|
|
| theorem plus_comm (R : P.Pool) (t j : Slot) (v w : P.Vec) : |
| P.plus (P.plus R t v) j w = P.plus (P.plus R j w) t v := by |
| ext k i |
| unfold plus; split_ifs <;> simp only [add_right_comm] |
|
|
| theorem plus_cancel (R : P.Pool) (t : Slot) (b : P.K) (v : P.Vec) : |
| P.plus (P.plus R t (P.multiple b v)) t (P.multiple (-b) v) = R := by |
| simp [plus_twice,multiple,plus_zero] |
|
|
| theorem plus_shift (R : P.Pool) (t : Slot) (b : P.K) (v : P.Vec) : |
| P.plus R t (P.multiple b v) t = P.shift (R t) v b := by |
| rw [plus_at]; rfl |
|
|
| end Modulus |
|
|
| namespace Circuit |
| variable (C : Circuit) |
| open Modulus Finset |
|
|
| abbrev Node := Fin C.nodes |
| def outerDegree := (C.count+1)*C.width |
| @[implicit_reducible] def P := Modulus.chosen C.outerDegree |
| abbrev F := C.P.K |
| abbrev Pool := C.P.Pool |
| abbrev Vec := C.P.Vec |
|
|
| / |
| def value (v : C.Node) : C.Vec := C.P.aug C.width (C.semantic v) |
| def YCount (v : C.Node) := 2 ^ C.guessing v |
|
|
| def G (v : C.Node) (z y h : ℕ) : C.F := C.propose v z y h |
| def test (v : C.Node) (z y i h a : ℕ) : C.F := C.allows v z y i h a |
| def EG (v : C.Node) (z y : ℕ) (h : C.Vec) := C.P.extWord C.width (C.G v z y) h |
| def ET (v : C.Node) (z y i : ℕ) (h a : C.Vec) := C.P.extTwo C.width (C.test v z y i) h a |
|
|
| / |
| structure Good : Prop where |
| bounded : ∀ v : C.Node, C.semantic v < 2^C.width |
| small : ∀ v : C.Node, C.guessing v ≤ C.width |
| leaf : ∀ v : C.Node, C.base v = true → C.semantic v = C.first v |
| identityRule : ∀ v : C.Node, C.base v = false → ∀ z ≤ C.width, |
| (∑ y ∈ range (C.YCount v), C.G v z y (C.semantic (C.head v)) * |
| ∏ i ∈ range C.count, C.test v z y i (C.semantic (C.head v)) |
| (C.semantic (C.child v i))) = C.value v z |
|
|
| / |
| structure Request where |
| node : C.Node |
| scale : C.F |
| target : Slot |
|
|
| namespace Request |
| variable {C} |
| def otherH (x : C.Request) (s : ℕ) : C.Request := |
| ⟨C.head x.node,s,Slot.H x.target⟩ |
| def otherA (x : C.Request) (i r : ℕ) : C.Request := |
| ⟨C.child x.node i,r,Slot.A x.target⟩ |
| def undo (x : C.Request) : C.Request := {x with scale := -x.scale} |
| def result (x : C.Request) (p : C.Pool) := |
| C.P.plus p x.target (C.P.multiple x.scale (C.value x.node)) |
| end Request |
|
|
| inductive Pc |
| | entry | outer | coord | guess | factor | sample | checkA |
| deriving DecidableEq |
|
|
| instance : Fintype Pc := |
| ⟨{.entry, .outer, .coord, .guess, .factor, .sample, .checkA}, |
| by intro p; cases p <;> simp⟩ |
|
|
| def Pc.code : Pc → ℕ |
| | .entry => 0 |
| | .outer => 1 |
| | .coord => 2 |
| | .guess => 3 |
| | .factor => 4 |
| | .sample => 5 |
| | .checkA => 6 |
|
|
| structure Frame where |
| x : C.Request |
| pc : Pc |
| s : Fin (C.P.n+1) |
| z : Fin (C.width+2) |
| y : Fin (2^C.width+1) |
| i : Fin (C.count+1) |
| r : Fin (C.P.n+1) |
| u : C.F |
| w : C.F |
|
|
| |
| |
| def clip (n : ℕ) (k : ℕ) : Fin (n+1) := |
| ⟨min n k,Nat.lt_succ_of_le (min_le_left _ _)⟩ |
| @[simp] theorem clip_ok (n k : ℕ) (h : k ≤ n) : |
| (clip n k).val = k := min_eq_right h |
|
|
| def form (x : C.Request) (pc : Pc) |
| (s z y i r : ℕ) (u w : C.F) : C.Frame := |
| ⟨x,pc,clip _ s,clip _ z,clip _ y,clip _ i,clip _ r,u,w⟩ |
| def fEntry (x : C.Request) : C.Frame := C.form x .entry 0 0 0 0 0 0 0 |
| def fOuter (x : C.Request) (s : ℕ) : C.Frame := C.form x .outer s 0 0 0 0 0 0 |
| def fCoord (x : C.Request) (s z : ℕ) : C.Frame := C.form x .coord s z 0 0 0 0 0 |
| def fGuess (x : C.Request) (s z y : ℕ) : C.Frame := C.form x .guess s z y 0 0 0 0 |
| def fFactor (x : C.Request) (s z y i : ℕ) (u : C.F) : C.Frame := |
| C.form x .factor s z y i 0 u 0 |
| def fSample (x : C.Request) (s z y i r : ℕ) (u w : C.F) : C.Frame := |
| C.form x .sample s z y i r u w |
| def fCheck (x : C.Request) (s z y i r : ℕ) (u w : C.F) : C.Frame := |
| C.form x .checkA s z y i r u w |
|
|
| def amount (x : C.Request) (s : ℕ) (u : C.F) := |
| (x.scale * C.P.weight C.outerDegree (s : C.F))*u |
|
|
| / |
| is scoped as scratch across pushes. After `checkA` release the |
| lookup work area; only one accumulated scalar is needed (plus u etc). |
| We compute w' (small) before the reverse push. |
| -/ |
| def atPc (R : C.Pool) (f : C.Frame) (p : Pc) : |
| C.Pool × FlowMove C.Frame := |
| let x := f.x |
| let s : ℕ := f.s |
| let z : ℕ := f.z |
| let y : ℕ := f.y |
| let i : ℕ := f.i |
| let r : ℕ := f.r |
| let u := f.u |
| let w := f.w |
| match p with |
| | .entry => |
| if C.base x.node then |
| (C.P.plus R x.target (C.P.multiple x.scale (C.P.aug C.width (C.first x.node))), |
| .finish) |
| else (R, .cont (C.fOuter x 0)) |
| | .outer => |
| if s < C.P.n then |
| (R, .call (C.fEntry (x.otherH s)) (C.fCoord x s 0)) |
| else (R, .finish) |
| | .coord => |
| if z < C.width+1 then (R, .cont (C.fGuess x s z 0)) |
| else (R, .call (C.fEntry (x.otherH s).undo) (C.fOuter x (s+1))) |
| | .guess => |
| if y < C.YCount x.node then |
| (R, .cont (C.fFactor x s z y 0 (C.EG x.node z y (R (Slot.H x.target))))) |
| else (R, .cont (C.fCoord x s (z+1))) |
| | .factor => |
| if i < C.count then (R, .cont (C.fSample x s z y i 0 u 0)) |
| else |
| (C.P.plus R x.target (C.P.spike (C.amount x s u) z), |
| .cont (C.fGuess x s z (y+1))) |
| | .sample => |
| if r < C.P.n then |
| (R, .call (C.fEntry (x.otherA i r)) (C.fCheck x s z y i r u w)) |
| else (R, .cont (C.fFactor x s z y (i+1) (u*w))) |
| | .checkA => |
| let w' := w + C.P.weight C.width (r : C.F) * |
| (C.ET x.node z y i (R (Slot.H x.target)) (R (Slot.A x.target))) |
| (R, .call (C.fEntry (x.otherA i r).undo) (C.fSample x s z y i (r+1) u w')) |
|
|
| open Bin |
| def packPool (R : C.Pool) := pair (C.P.packed C.width (R 0)) |
| (pair (C.P.packed C.width (R 1)) (C.P.packed C.width (R 2))) |
|
|
| def packX (x : C.Request) := pair x.target.val (pair x.node.val x.scale.val) |
|
|
| def packFrame (f : C.Frame) := |
| pair (C.packX f.x) (pair f.pc.code (pair f.s.val (pair f.z.val (pair f.y.val |
| (pair f.i.val (pair f.r.val (pair f.u.val f.w.val))))))) |
|
|
| def flow : Flow := |
| ⟨C.Pool,C.Frame,C.packPool,C.packFrame,fun R f => C.atPc R f f.pc⟩ |
|
|
| / |
| def price (g : ℕ) := |
| 100 * ((((((1+C.nodes.size)+C.width.size)+C.count.size)+C.P.n.size)+g)+1) |
|
|
| structure Meter (coins : C.Node → ℕ) : Prop where |
| cheap : ∀ v : C.Node, C.base v = false → |
| coins (C.head v) + C.price 0 ≤ coins v |
| expensive : ∀ v : C.Node, C.base v = false → ∀ i < C.count, |
| coins (C.child v i) + C.price (C.guessing v) ≤ coins v |
|
|
| theorem price_bounds (f : C.Frame) (g : ℕ) (h : f.y.val.size ≤ g+1) : |
| C.flow.fee f ≤ C.price g := by |
| have a : f.pc.code.size ≤ 4 := by cases f.pc <;> decide |
| have b : f.x.target.val.size ≤ 2 := by |
| have := Nat.size_le_size f.x.target.isLt.le |
| exact this.trans (show Nat.size 3 ≤ 2 by decide) |
| have c := Nat.size_le_size f.x.node.isLt.le |
| have p := Nat.size_le_size (show f.i.val ≤ C.count from Nat.le_of_lt_succ f.i.isLt) |
| have r := Nat.size_le_size (show f.s.val ≤ C.P.n from Nat.le_of_lt_succ f.s.isLt) |
| have q := Nat.size_le_size (show f.r.val ≤ C.P.n from Nat.le_of_lt_succ f.r.isLt) |
| have z := Nat.size_le_size (show f.z.val ≤ C.width+1 from Nat.le_of_lt_succ f.z.isLt) |
| have e := Bin.succ_size C.width |
| have l (x : C.F) : x.val.size ≤ C.P.n.size := Nat.size_le_size (ZMod.val_lt x).le |
| have l₁ := l f.x.scale |
| have l₂ := l f.u |
| have l₃ := l f.w |
| change 2*(C.packFrame f).size + 1 ≤ C.price g |
| simp only [packFrame,packX,pair_size,price] |
| omega |
| end Circuit |
| end Fifths |
|
|
| end OAI |
|
|
