Skip to main content

Computation & Compile

Every compute call in Zeq is a declared compile path: you name the operators, the framework runs the domain's closed-form solver, and the result comes back with a hash that makes it replayable.

  • Theme — computation-compile
  • Protocol count — 34 (wizard, solve, operator-admit, pipeline-sign, replay, audit variants)
  • Anchor operators — KO42 · CS43 · CS46
  • Verification — bit-exact compile-path hash; each result independently re-derivable against textbook physics

What it solves​

A Zeq compute call is not an opaque function invocation — it's a compile-path declaration. The caller nominates operators (e.g. ["KO42","NM19","NM30"]); the framework runs them through the 7-step wizard — SELECT the domain, BIND CODATA constants, VALIDATE the inputs, COMPUTE the domain's closed-form solver, VERIFY, PULSE (phase-stamp), RETURN — and hands back the numeric value, its unit and uncertainty, and a compile-path hash. That hash is the reproducibility contract: the same operators and inputs re-derive the same value on any node.

Each transition records the verbatim registry equation the operator evaluated in the envelope's master_equation_block, so a reader can see exactly which textbook formula produced the number — and check it by hand. The framework composes known equations on a shared clock; it does not reduce them to a single super-equation before executing. KO42 is the always-on time base; the physics operator is the verb that runs.

Every protocol in this theme is a verb on that path: compute (run the solver), admit (register a new operator), audit (re-run a stored compile-path), pipeline-sign (sign a linked run of compile-paths), replay (bit-exact reproduction).

Operator map​

OperatorFormulaRole
KO42.1ds² = g_μν dx^μ dx^ν + α sin(2π · 1.287 t) dt²Mandatory Prime step
CS43T(n) = O(n log n)Time-complexity bound declared by compile-path
CS46P(n) = 1/[(1 − f) + f/n]Parallel speedup Amdahl bound

Runnable worked example — compile + replay​

# 1. Compile and run
curl -s -X POST https://zeqsdk.com/api/playground/compute \
  -H "Authorization: Bearer $ZEQ_DEMO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "operators": ["KO42", "NM19", "NM30"],
    "inputs": {"protocol": "compute", "example": "pendulum", "L_m": 1.0, "g_m_s2": 9.81}
  }'

Expected:

{
  "result": {"period_s": 2.0071, "error_pct": 0.0298},
  "compile_path_hash": "sha256:...",
  "zeqond": 2287439213,
  "phase": 0.054
}
# 2. Replay — must produce byte-identical result
curl -s -X POST https://zeqsdk.com/api/playground/compute \
  -H "Authorization: Bearer $ZEQ_DEMO_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "operators": ["KO42", "NM19", "NM30"],
    "inputs": {"protocol": "replay", "compile_path_hash": "sha256:..."}
  }'

Extend it​

  • Operator admission — submit a new operator via admit; the framework validates its verbatim formula against the kernel registry.
  • Pipeline signing — chain N compile calls, sign the entangled state with a tether quorum; audit the whole pipeline as one artefact.
  • Distributed compile — split a large solver evaluation across GPUs; CS46 bounds the speedup exactly.

Seeds​

  • Operator version negotiation — two peers with different operator registry versions can negotiate a common subset before compiling.
  • Proof-carrying compute — embed a ZK proof of "this compile-path was actually run" alongside every result.
  • Auto-Wizard — a solver that picks the minimal operator tuple to hit a user's error budget. Already partially present in the hosted endpoint.

Papers​

Middleware active. Kernel on the 1.287 Hz HulyaPulse. Awaiting next Zeqond.