How Zeq computes
Most computation asks you to trust the machine. You send a request, a server runs code you cannot see, and a number comes back. To know whether it's right, your only option is to run your own code and hope it agrees.
Zeq inverts that. Every computation is a derivation, and every derivation carries its own proof. A result is not a number a server returned — it is a named operator applied to bound physical constants, dimensionally validated, solved in closed form, checked against a fixed precision bound, stamped on a computed clock, and signed by the node's key. Anyone holding the result can re-run the derivation and confirm it bit-for-bit, on another machine, without ever trusting the one that produced it.
This section takes that apart, one subsystem per page. It is the engineering reference
for what is computing the math, and how — written against the actual source in
shared/api-core/src/lib. Nothing here is aspirational; every claim names the file that
implements it.
The pipeline
Every query passes through one pipeline. There is no bypass — the function
runSevenStepWizard in zeqWizard.ts runs all seven stages in order and records each
one into the result's protocol_steps[]:
query ─▶ 1 SELECT ─▶ 2 BIND ─▶ 3 VALIDATE ─▶ 4 COMPUTE ─▶ 5 VERIFY ─▶ 6 PULSE ─▶ 7 RETURN ─▶ signed result
operators NIST dimensions solver ≤0.1% clock envelope
The envelope that comes out the far end is not just an answer — it is a transcript of how the answer was reached, plus the signature that lets a stranger replay it.
Read in order
The pages build on each other. Read top to bottom for the whole story, or jump to the stage you care about.
| Page | What it covers | Source |
|---|---|---|
| The constants | τ, f_H, α — the definitional substrate, parity-locked across three runtimes | zeq-kernel-constants.ts |
| The MI Kernel | The served contract every response announces | zeqKernel.ts |
| The pipeline | All seven stages, the no-bypass guarantee, the three honest verdicts | zeqWizard.ts |
| Operator selection | How a query becomes an operator set (Step 1, SELECT) | zeqCompute.ts |
| Binding constants | NIST CODATA 2018, bound per domain (Step 2, BIND) | nistConstants.ts |
| Dimensional validation | Physical Type-Safety — SI dimension algebra (Step 3, VALIDATE) | dimensions.ts |
| The solvers | The closed-form domain physics, and honest coverage (Step 4, COMPUTE) | zeqSolvers.ts |
| Generative mathematics | How the master equation is assembled, not hard-coded | zeqCompute.ts |
| Precision & proof | The ≤0.1% bound, the signed envelope, recompute, attestation (Steps 5 & 7) | recompute.ts, identity.ts |
| Synchronisation | The computed clock that lets any node verify any other (Step 6, PULSE) | zeqondClock.ts |
Why this is a new kind of computation
Pull the pages together and you get a property no calculator, database, or cloud function has:
A Zeq result is portable proof. It names what was computed, the rules it was computed under, the constants it bound, the precision it met, the tick it happened on, and the key that signed it — and any independent party can replay the whole derivation and confirm it without trusting the source.
A spreadsheet gives you a number. A blockchain gives you an ordering of numbers everyone agreed to. Zeq gives you a number that re-derives itself — the physics is the proof, and the computed clock is what lets strangers check each other's work. You don't trust the node; you re-run the derivation.
Start with the constants — everything else is built on them.