Skip to main content

Composing operators

You select operators in practice by passing an operators array to a protocol call; the framework routes to the dedicated solver for the domain and computes the standard physics. (The literature's Σ_{k=1..42} C_k(ϕ) term is organisational notation, not a runtime sum — see The operators.)

The rule of 4​

Step 2 of the 7-step wizard protocol: max 4 operators per call, and one of them must be KO42. So: 1 to 3 operators of your choice, plus KO42.

// valid: KO42 + QM9 + NM23
const cko = await zeq.compute({
  operators: ["QM9", "NM23"],  // KO42 is prepended by the kernel
  inputs: { m_kg: 1, v_mps: 100 },
});

// INVALID: 4 user operators — the API rejects with HTTP 400
await zeq.compute({
  operators: ["QM9", "NM23", "GR31", "CS47"],
  inputs: { /* ... */ },
});
// → 400: at most 3 operators beyond the mandatory KO42

Why the limit? It keeps each call to a small, auditable set of operators the wizard can validate and sign cleanly — a protocol contract, not a numerical-accuracy claim. (KO42 itself is the bounded HulyaPulse modulation applied once per result; it does not "prove" a physical error band — see KO42.) If you need a deeper composition, chain CKOs: run two protocols, feed the first's output into the second's parameters.

A worked example: time-dilated kinetic energy​

A ship passing near a gravitating body; compute kinetic energy in its proper frame.

const cko = await zeq.compute({
  operators: [
    "GR35",   // time dilation
    "NM23",   // kinetic energy
  ],
  inputs: {
    m_kg:      1000,
    v_mps:     1e6,
    G:         6.674e-11,
    M_kg:      5.972e24,  // Earth mass
    r_m:       6.371e6,   // Earth radius
  },
});

console.log(cko.value, cko.unit);
// the computed result + unit for the dispatched operator.

console.log(cko.zeqState.operators);
// ["KO42", "GR35", "NM23"]  (KO42 is always first)

console.log(cko.zeqState.precision);
// the KO42 modulation amplitude |α·sin| at this tick (≤0.1% by
// construction). It is protocol bookkeeping, not a measured
// deviation of the physics value from ground truth.

Chaining CKOs​

When you need more than 3 operators, chain. Each link is independently KO42-verified:

const step1 = await zeq.compute({
  operators: ["QM9"],
  inputs: { /* ... */ },
});

const step2 = await zeq.compute({
  operators: ["GR35", "NM23"],
  inputs: {
    ...otherInputs,
    incoming_lambda_m: step1.value,  // thread the output
  },
});

// Both CKOs are independently verifiable — each carries its own signed
// claim and zeqProof. The per-call KO42 modulation is reported in
// step1.zeqState.precision and step2.zeqState.precision.

Picking the right operators​

Step 3 of the wizard protocol: match operators to the domain. Some rules of thumb:

  • Quantum-scale problems (atomic, photonic, sub-µm): start with a QM operator (QM1, QM5, QM9, QM17).
  • Mesoscale / everyday physics (balls, cars, pendula): start with NM (NM19, NM23, NM26, NM30).
  • High-energy or astrophysics (near black holes, cosmological scales): start with GR (GR32, GR35, GR37).
  • Algorithm / information problems: CS (CS43 for performance, CS47 for entropy, CS87 for minimum descriptor length).

(The Awareness operators are speculative and are not computed by the API — don't reach for them for real problems.)

When in doubt, browse the catalogue with getOperators() from @zeq/sdk/operators (or GET /api/operators) and pick by domain.

Next​

Use a pre-built protocol → Calling a protocol.