How equations combine

When you send "operators": ["KO42", "GR37"], you're naming a chain. This page explains exactly how the engine combines them — what each term contributes, where the physics value comes from, and why the clock modulation never contaminates it. Every number below is from one real envelope (GR37, Sun's mass), so you can reproduce the decomposition yourself.

Two kinds of operator in a chain

A chain always has KO42 first, then your physics operators:

• KO42 is the mandatory modulation / clock operator. It carries no physics of its own — its job is to phase-stamp the result to the 1.287 Hz HulyaPulse, with an amplitude capped at 0.1% by construction. Its equation is $R(t) = S_0[1 + \alpha\sin(2\pi f_H t)]$, $S_0=1$, $\alpha=10^{-3}$.
• Domain operators (GR37, NM19, …) carry the actual maths. Each is a named standard formula the domain solver evaluates on your inputs.

So "combining" is not "add the equations together into a soup." The engine keeps the physics value and the clock carrier on separate tracks and reports both. Conflating them is the single most common misreading of the framework — the code goes out of its way to prevent it.

The ground state $S(t)$

Every compute has a ground state $S(t)$ — a scalar the modulation rides on. For a normal physics call the reported answer is the solver's own value; the ground state used for the carrier is normalised to $S(t)=1$, so the carrier is a pure, dimensionless clock factor. (When the master-sum explorer renders a multi-term breakdown, $S(t)$ is the RMS of the normalised inputs — $S(t) = \langle |\text{inputs}| \rangle$ — so weights across operators are commensurate.)

The carrier $R(t)$

The KO42 contribution is a single bounded factor sampled at compute time:

$$R(t) = S(t)\,\bigl[\,1 + \alpha\sin(2\pi f_H t)\,\bigr] = \underbrace{S(t)}_{\text{ground state}} + \underbrace{\alpha\,S(t)\sin(2\pi f_H t)}_{\text{HulyaPulse modulation}}$$

Because $\alpha = 10^{-3}$, the modulation term is at most 0.1% of $S(t)$ — and averaged over one Zeqond (0.777 s) the sine integrates to zero, so $R(t)$ recovers $S(t)$ exactly. The clock adds information about when, not error about what.

On the real call, at tick $\tau = 2296532592$, phase $0.0478$:

{ "S_t": 1, "R_t": 1.000296, "alpha_K": 0.001, "hulyapulse_hz": 1.287000000001287 }

$R(t) = 1.000296$ — i.e. the compute happened at a moment when the carrier was +0.0296% above ground.

Physics value vs. modulated value

Here is the part that makes it concrete. The result block of the same envelope:

{ "value": 2954.0077, "bare_value": 2954.0077, "carrier": 1.0002961,
  "modulated_value": 2954.8825, "unit": "m", "uncertainty": 0.029540077 }

Read it as three columns:

Field	Value	Meaning
bare_value	2954.0077 m	the physics — $2GM/c^2$, what you report
carrier	1.0002961	the KO42 clock factor $R(t)/S(t)$ at this tick
modulated_value	2954.8825 m	bare_value × carrier — the clock-stamped form

The top-level value the API returns is the bare physics value. The modulated value is offered alongside for anyone who wants the time-stamped number, but the answer to "what is the Schwarzschild radius of the Sun" is 2954.0077 m, full stop. The carrier is bookkeeping.

The master sum — term by term

For explorers and audits, the engine emits a master_sum breakdown so a result can be rendered as a faithful table without inventing decompositions it didn't compute (shared/api-core/src/lib/masterSum.ts). It has exactly one row per operator plus the ground state:

Row	Operator	Role	Contribution
0	S(t)	ground state	the RMS ground state
1	KO42	modulation	$\alpha\cdot S(t)\cdot\sin(2\pi f_H t)$ — numeric, ≤0.1%
2…	GR37, …	domain / awareness	symbolic — applied to inputs by the domain solver

Note the honesty of row 2: a domain operator's contribution is marked symbolic, not given a fake scalar share of the total. The engine knows the physics value came out of the domain solver as a whole; it does not pretend to have split 2954 m into per-operator percentages it never calculated.

Multiple physics operators

When a chain names several domain operators, the engine resolves the primary operator for the answer (the one your inputs actually determine) and records the others on the chain. The masterEquation string assembles them into one human-readable statement — variables, each operator's formula, and the synthesized combination — so you can see the full set that was in scope. This is assembly for legibility and audit; the numeric answer is still the primary solver's value, checked by the precision gate and re-computed independently.

If two operators genuinely describe a coupled system (a trajectory, an N-body problem), that's not algebraic combination at all — it goes to the ODE engine, which integrates the coupled field equations together with a vector RK4 stepper. See the solvers and multi-body for that path.

Why keep them separate

Keeping physics and clock on separate tracks is what lets a ZeqProof from one node verify on another: the proof binds operator | result | zeqond, so a verifier re-runs the bare physics and checks the clock stamp independently. If the modulation were baked into the value, no two ticks would ever agree and nothing would be verifiable. The separation isn't decoration — it's what makes the whole proof system work.

Read next

• The execution model — the full CPU-level trace this envelope came from.
• The master equation — the HULYAS field equation the ODE path integrates.
• The Zeq envelope — every field the compute returns, and how to verify it.
• The clock — HulyaPulse, Zeqond, and the exact tick arithmetic.