| import OAI.Computability.SpaceSimulation.Evaluation.Next |
| import OAI.Computability.SpaceSimulation.Evaluation.Schedule |
|
|
| namespace OAI |
|
|
| namespace Fifths |
| namespace Circuit |
| open Bin Fifths.Comp Modulus |
| variable {I X : Type} {C : I → Circuit} {x : I → List X} {S cp : I → ℕ} |
|
|
| set_option maxHeartbeats 300000 |
| attribute [local irreducible] Bin.pair Modulus.chosen |
| private theorem pic : Function.Injective Pc.code := by |
| intro a b h |
| cases a <;> cases b <;> simp_all only [Pc.code] <;> contradiction |
|
|
| theorem Ready.flow_uniform (c : Ready C x S cp) (g : ∀ i, (C i).Good) : |
| Flow.uniform (fun i => (C i).flow) x S cp := by |
| let v := Flow.Points (fun i => (C i).flow) |
| let r := fun i : v => i.1 |
| let D := fun i : v => C (r i) |
| let R : ∀ i : v, (D i).Pool := fun i => i.2.1 |
| let f : ∀ i : v, (D i).Frame := fun i => i.2.2 |
| let a := fun i : v => (D i).flow.input (cp (r i)) (R i) (f i) |
| have s : Fits (fun i : v => S (r i)) a := |
| (c.widthOf.source.pull r).pair ((c.poolSpace R).pair (c.frameSpace f)) |
| have h := Comp.refl (x := fun i => x (r i)) s |
| have p₁ : Comp.ReComp x S r a (fun i => cp (r i)) := h.left |
| have p₂ : Comp.ReComp x S r a (fun i => (D i).packPool (R i)) := h.right.left |
| have p₃ : Comp.ReComp x S r a (fun i => (D i).packFrame (f i)) := h.right.right |
| have z : ReComp x S r a (fun i => (f i).pc.code) := Comp.left (Comp.right p₃) |
| exact chooseCase Pc.code pic |
| (fun i k => (D i).flow.packMove ((D i).atPc (R i) (f i) k)) |
| z (fun k => c.byPc g _ _ _ _ p₁ p₂ p₃ k) |
|
|
| /-- Compute the designated word using only the requested budget. |
| All sizes in `Ready`, `Scaled` and `Comp` are uniform. -/ |
| theorem evaluate (c : Ready C x S cp) (g : ∀ i, (C i).Good) |
| (B : ∀ i, (C i).Node → ℕ) (funding : ∀ i, (C i).Meter (B i)) |
| (v : ∀ i, (C i).Node) |
| (w : Comp x S cp (fun i => (v i).val)) |
| (h : Scaled S (fun i => B i (v i))) : |
| Comp x S cp (fun i => (C i).semantic (v i)) := by |
| let q : ∀ i, (C i).Request := fun i => ⟨v i,1,0⟩ |
| let R : ∀ i, (C i).Pool := fun _ _ _ => 0 |
| let f := fun i => (C i).fEntry (q i) |
| let t := fun i => (q i).result (R i) |
| have e := Flow.uniform_result (c.flow_uniform g) R t f _ h |
| (fun i => (C i).answers (B i) (g i) (funding i) (v i) (q i) rfl (R i)) |
| let P := fun i => (C i).P |
| have cp₁ := c.modulusN |
| have d := c.fitRegisters |
| have b : Comp x S cp (fun i => (C i).packPool (R i)) := by |
| apply combinePool |
| intro s |
| apply vector d cp₁ c.widthOf _ |
| intro U r a j v _ _ |
| exact valZero (Comp.trans v (cp₁.pull r)) |
| have o := Comp.constant (x := x) w.source 0 |
| have m : Comp x S cp (fun i => (C i).packX (q i)) := |
| o.pair (w.pair (valOne cp₁)) |
| have f₁ : Comp x S cp (fun i => (C i).packFrame (f i)) := |
| formComp d cp₁ c.widthOf _ m c.countOf o o o o o (valZero cp₁) (valZero cp₁) |
| have s₁ : Comp x S cp (fun i => (C i).flow.input (cp i) (R i) (f i)) := |
| (Comp.refl w.source).pair (b.pair f₁) |
| have m₀ : Comp x S cp (fun i => (C i).packPool (t i)) := |
| s₁.trans e |
| have L (i : I) (k : ℕ) : t i 0 k = |
| (C i).P.aug (C i).width ((C i).semantic (v i)) k := by |
| simp [q,R,t,Request.result,plus,multiple,value] |
| have H : Comp x S cp (fun i => Radix.pack 2 (fun k => (t i 0 k).val) (C i).width) := by |
| refine digits (Comp.constant w.source 2) c.widthOf (fitBitsD d) |
| (fun i => by omega) (fun i k => (t i 0 k).val) |
| (fun i k _ => ?_) ?_ |
| · rw [L, aug_val]; exact aug_bounded .. |
| · intro e g v |
| let a := fun i : Before (fun i => (C i).width) => i.1.1 |
| exact coord (d.pull a) (g.trans (cp₁.pull a)) |
| (g.trans ((which m₀ 0).pull a)) v (fun i => i.2.le) |
| exact H.congr fun i => by simp [L, Modulus.fromAug,(g i).bounded] |
|
|
| end Circuit |
| end Fifths |
|
|
| end OAI |
|
|
