lean/OAI/Computability/SpaceSimulation/Evaluation/Ready.lean

import OAI.Computability.SpaceSimulation.Evaluation.Circuit
import OAI.Computability.SpaceSimulation.Register.Static

namespace OAI

/-! Uniform circuit presentation. In contrast to lookup-table evaluation
as a pure algebraic object, actual computation of a Boolean assignment's
function value is needed. -/
namespace Fifths
namespace Circuit
open Bin Modulus Fifths.Comp
variable {I X U : Type}

structure Ready (C : I → Circuit) (x : I → List X) (S cp : I → ℕ) : Prop where
  widthOf : Comp x S cp (fun i => (C i).width)
  countOf : Comp x S cp (fun i => (C i).count)
  fitNodes : Fits S (fun i => (C i).nodes)
  fitRegisters : Fits S (fun i => (C i).P.n ^ ((C i).width+1))
  nav : ∀ {U : Type} (r : U → I) {a} (v : ∀ i, (C (r i)).Node),
    ReComp x S r a (fun i => cp (r i)) →
    ReComp x S r a (fun i => (v i).val) →
    ReComp x S r a (fun i => ((C (r i)).base (v i)).toNat) ∧
    ReComp x S r a (fun i => (C (r i)).guessing (v i)) ∧
    ReComp x S r a (fun i => ((C (r i)).head (v i)).val) ∧
    ReComp x S r a (fun i => (C (r i)).first (v i))
  children : ∀ {U : Type} (r : U → I) {a} (v : ∀ i, (C (r i)).Node) k,
    ReComp x S r a (fun i => cp (r i)) →
    ReComp x S r a (fun i => (v i).val) → ReComp x S r a k →
    (∀ i, k i ≤ (C (r i)).count) →
    ReComp x S r a (fun i => ((C (r i)).child (v i) (k i)).val)
  proposeOf : ∀ {U : Type} (r : U → I) {a} (v : ∀ i, (C (r i)).Node) z y h,
    ReComp x S r a (fun i => cp (r i)) →
    ReComp x S r a (fun i => (v i).val) →
    ReComp x S r a z → ReComp x S r a y → ReComp x S r a h →
    (∀ i, z i ≤ (C (r i)).width+1) → (∀ i, y i ≤ 2^(C (r i)).width) →
    (∀ i, h i < 2^(C (r i)).width) →
    ReComp x S r a (fun i => (C (r i)).propose (v i) (z i) (y i) (h i))
  allowOf : ∀ {U : Type} (r : U → I) {a} (v : ∀ i, (C (r i)).Node) z y k h b,
    ReComp x S r a (fun i => cp (r i)) →
    ReComp x S r a (fun i => (v i).val) →
    ReComp x S r a z → ReComp x S r a y → ReComp x S r a k →
    ReComp x S r a h → ReComp x S r a b →
    (∀ i, z i ≤ (C (r i)).width+1) → (∀ i, y i ≤ 2^(C (r i)).width) →
    (∀ i, k i ≤ (C (r i)).count) →
    (∀ i, h i < 2^(C (r i)).width) → (∀ i, b i < 2^(C (r i)).width) →
    ReComp x S r a (fun i => (C (r i)).allows (v i) (z i) (y i) (k i) (h i) (b i))

section Independent
-- Small reusable constructions on represented values.
variable {C : I → Circuit} {x : I → List X} {S a : I → ℕ}

theorem slotMap (s : Slot → Slot) {q : I → Slot}
    (h : Comp x S a (fun i => (q i).val)) :
    Comp x S a (fun i => (s (q i)).val) :=
  chooseCase Fin.val Fin.val_injective (fun _ j => (s j).val) h
    (fun _j => Comp.constant h.source _)

theorem which {R : ∀ i, (C i).Pool}
    (p : Comp x S a (fun i => (C i).packPool (R i)))
    (s : Slot) : Comp x S a
    (fun i => (C i).P.packed (C i).width (R i s)) := by
  fin_cases s
  · exact p.left
  · exact p.right.left
  · exact p.right.right

theorem chooseSlot {R : ∀ i, (C i).Pool}
    (p : Comp x S a (fun i => (C i).packPool (R i)))
    {q : I → Slot}
    (h : Comp x S a (fun i => (q i).val)) :
    Comp x S a (fun i => (C i).P.packed (C i).width (R i (q i))) :=
  chooseCase Fin.val Fin.val_injective (fun i k => (C i).P.packed (C i).width (R i k)) h (which p)

theorem combinePool {R : ∀ i, (C i).Pool}
    (p : ∀ s : Slot, Comp x S a (fun i => (C i).P.packed (C i).width (R i s))) :
    Comp x S a (fun i => (C i).packPool (R i)) :=
  (p 0).pair ((p 1).pair (p 2))

variable (s : Fits S (fun i => (C i).P.n ^ ((C i).width+1)))
    (p : Comp x S a (fun i => (C i).P.n))
    (q : Comp x S a (fun i => (C i).width))
include s p q

theorem plusComp {R : ∀ i, (C i).Pool}
    (w : Comp x S a (fun i => (C i).packPool (R i))) {t : I → Slot}
    (v : Comp x S a (fun i => (t i).val)) {d : ∀ i, (C i).Vec}
    (h : Comp x S a (fun i => (C i).P.packed (C i).width (d i))) :
    Comp x S a (fun i => (C i).packPool ((C i).P.plus (R i) (t i) (d i))) := by
  apply combinePool
  intro k
  have e := which w k
  have l : Comp x S a (fun i => (C i).P.packed (C i).width
      (fun j => R i k j + d i j)) := by
    apply vector s p q _
    intro U r a j u c g
    let f := fun i => (C (r i)).P
    have x := u.trans (p.pull r)
    refine fieldAdd (P := f) x ?_ ?_
    · exact coord (s.pull r) x (u.trans (e.pull r)) c g
    · exact coord (s.pull r) x (u.trans (h.pull r)) c g
  refine ((v.eq (Comp.constant v.source k.val)).iteB l e).congr (fun i => ?_)
  by_cases g : k = t i
  · simp [← g,plus_at]
  · have f := Fin.val_injective.ne (Ne.symm g)
    simp [f,(C i).P.plus_other _ _ g]

theorem jump {b : ∀ i, (C i).F} (w : Comp x S a (fun i => (b i).val))
    {g : I → ℕ} (h : Comp x S a g) :
    Comp x S a (fun i => (C i).P.packed (C i).width
      ((C i).P.multiple (b i) ((C i).P.aug (C i).width (g i)))) := by
  apply vector s p q _
  intro U r a j e c m
  have x := e.trans (p.pull r)
  exact fieldMul x (e.trans (w.pull r)) (valCast x
    (wordBit (s.pull r) x (e.trans (q.pull r)) (e.trans (h.pull r)) c m))

theorem jumpOne {b : ∀ i, (C i).F} (w : Comp x S a (fun i => (b i).val))
    {g : I → ℕ} (h : Comp x S a g) :
    Comp x S a (fun i => (C i).P.packed (C i).width
      ((C i).P.spike (b i) (g i))) := by
  apply vector s p q _
  intro U r a j e c m
  have x := e.trans (p.pull r)
  refine ((c.eq (e.trans (h.pull r))).iteB (e.trans (w.pull r)) (valZero x)).congr
    (fun i => ?_)
  by_cases f : j i = g (r i) <;> simp [spike,f]

theorem formComp (k : Pc) {X' : ∀ i, (C i).Request} (w : Comp x S a
      (fun i => (C i).packX (X' i)))
    (r : Comp x S a (fun i => (C i).count))
    {s' z y j m : I → ℕ} {b g : ∀ i, (C i).F} (c₁ : Comp x S a s') (c₂ : Comp x S a z)
    (c₃ : Comp x S a y) (c₄ : Comp x S a j) (c₅ : Comp x S a m)
    (c₆ : Comp x S a (fun i => (b i).val)) (c₇ : Comp x S a (fun i => (g i).val)) :
    Comp x S a (fun i => (C i).packFrame ((C i).form (X' i) k (s' i) (z i) (y i)
      (j i) (m i) (b i) (g i))) :=
  w.pair ((Comp.constant w.source k.code).pair
    ((p.min c₁).pair ((q.plus1.min c₂).pair
      ((((Comp.constant p.source 2).pow q (fitBitsD s)).min c₃).pair
        ((r.min c₄).pair ((p.min c₅).pair (c₆.pair c₇)))))))
end Independent

namespace Ready
variable {C : I → Circuit} {x : I → List X} {S cp : I → ℕ}

theorem uniformDegree (c : Ready C x S cp) :
    Comp x S cp (fun i => (C i).outerDegree) :=
  c.countOf.plus1.mul c.widthOf

theorem modulusN (c : Ready C x S cp) :
    Comp x S cp (fun i => (C i).P.n) :=
  c.uniformDegree.chosenN

theorem frameSpace (c : Ready C x S cp) {r : U → I} (f : ∀ i, (C (r i)).Frame) :
    Fits (fun i => S (r i)) (fun i => (C (r i)).packFrame (f i)) := by
  have h₁ := c.fitNodes.pull r
  have h₂ := c.modulusN.target.pull r
  have h₃ := c.widthOf.target.pull r
  have h₄ := c.countOf.target.pull r
  have h₅ := (fitBitsD c.fitRegisters).pull r
  have w (g : ∀ i, (C (r i)).F) := fitElement (P := fun i => (C (r i)).P) h₂ g
  have q : Fits (fun i => S (r i)) (fun i => (C (r i)).packX (f i).x) :=
    ((Fits.const _ 3).mono (fun i => (f i).x.target.isLt.le)).pair
      ((h₁.mono (fun i => (f i).x.node.isLt.le)).pair (w _))
  refine q.pair (((Fits.const _ 7).mono ?_).pair
    ((h₂.mono ?_).pair (((h₃.add (Fits.const _ 1)).mono ?_).pair
       ((h₅.mono ?_).pair ((h₄.mono ?_).pair ((h₂.mono ?_).pair ((w _).pair (w _))))))))
  · intro i; cases (f i).pc <;> decide
  all_goals intro i
  · exact Nat.le_of_lt_succ (f i).s.isLt
  · exact Nat.le_of_lt_succ (f i).z.isLt
  · exact Nat.le_of_lt_succ (f i).y.isLt
  · exact Nat.le_of_lt_succ (f i).i.isLt
  · exact Nat.le_of_lt_succ (f i).r.isLt

theorem poolSpace (c : Ready C x S cp) {r : U → I} (R : ∀ i, (C (r i)).Pool) :
    Fits (fun i => S (r i)) (fun i => (C (r i)).packPool (R i)) := by
  have f (j : Slot) := fitPacked (P := fun i => (C (r i)).P)
    (c.fitRegisters.pull r) (fun i => R i j)
  exact (f 0).pair ((f 1).pair (f 2))
end Ready
end Circuit
end Fifths

end OAI