الانتقال إلى المحتوى الرئيسي

Computation & Compile

Every compute call in Zeq is a compile path through the HULYAS Master Equation. This theme documents the protocol that turns operator choices into a verified result.

  • Theme — computation-compile
  • Protocol count — 34 (wizard, master, functional, spectral-topological, operator-admit, pipeline-sign, replay, audit variants)
  • Anchor operators — KO42 · CS43 · CS46
  • Verification — ≤ 0.1% against the chosen benchmark; bit-exact compile-path hash

What it solves​

A Zeq compute call is not a function invocation — it's a compile-path declaration. The caller nominates operators (e.g. ["KO42","NM19","NM30"]), the framework compiles them through the 7-step Wizard into the Master Equation, executes via the Functional Equation, and returns both the numeric result and the compile-path hash. That hash is the reproducibility contract.

The Master Equation is:

□ϕ − μ²(r)ϕ − λϕ³ − e^{-ϕ/ϕ_c} + ϕ₄₂ ∑_{k=1}^{42} C_k(ϕ) = T^μ_μ + β F_{μν} F^{μν} + J_{ext}

The Functional Equation is:

E = P_ϕ · Z(M, R, δ, C, X)

The Spectral-Topological Equation wraps the above:

Ψ(x,t) = ∭ K(x,x',t,t') ϕ(x',t') dx' dt'

Every protocol in this theme is a verb on that substrate: compute (execute), admit (register a new operator), audit (re-run a stored compile-path), pipeline-sign (sign an entangled state 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://api.zeq.dev/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": 1745125100.042
}
# 2. Replay — must produce byte-identical result
curl -s -X POST https://api.zeq.dev/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 the Master Equation 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.