The constants

Everything Zeq computes is anchored to three values. They are defined once, in shared/api-core/src/lib/zeq-kernel-constants.ts, and that file is the single source of truth for the runtime. Two other copies — the public SDK (@zeq/sdk) and the Python daemon — must declare the same primitive values, and a parity test fails the build if they ever drift.

The three values

// Zeqond duration in integer nanoseconds. EXACT. The source-of-truth primitive.
export const ZEQOND_NS: bigint = 777_000_777n;

// KO42 amplitude-modulation coefficient. EXACT. |α·sin| ≤ 0.1% by construction.
export const ALPHA_K: number = 1e-3;

// Derived — mechanically, so they cannot drift from the primitive:
export const TAU_ZQ: number = Number(ZEQOND_NS) / 1e9;   // 0.777000777 s
export const F_H:    number = 1e9 / Number(ZEQOND_NS);   // ≈ 1.287000000001287 Hz

Symbol	Meaning	Value
τ (ZEQOND_NS / TAU_ZQ)	The Zeqond — the framework's unit of time	777,000,777 ns = 0.777000777 s, exact
f_H (F_H)	The HulyaPulse frequency — the system clock's heartbeat	10⁹ / 777,000,777 Hz ≈ 1.287000000001287 Hz
α (ALPHA_K)	The KO42 modulation coefficient	10⁻³, exact

They are definitional, not measured

This is the most important thing to understand about the constants, and the place earlier versions of the framework got it wrong.

τ is defined to be exactly 777,000,777 nanoseconds — the way the SI second is defined by a count of caesium transitions. The framework does not measure the Zeqond; it declares it, and f_H follows as 1/τ. That is the whole story: one exact integer, everything else derived from it by exact arithmetic. Whether this shared computational constant also corresponds to something in nature is an open question the framework does not claim to settle — it claims only that the constant is exact, shared, and load-bearing.

Because f_H and τ are reciprocals built from the same integer, their product is exactly 1 in exact arithmetic:

f_H · τ = (10⁹ / ZEQOND_NS) · (ZEQOND_NS / 10⁹) = 1     (exactly, in ℚ)

In IEEE-754 doubles the product is 1.0 ± 1 ulp (~2.2 × 10⁻¹⁶), and the module asserts this at load time outside production — if f_H · τ ever deviates by more than 10⁻¹⁵, the process refuses to start. The same self-check pins ZEQOND_NS === 777_000_777n (catching a 777_777_777 transcription error) and ALPHA_K ≤ 0.001.

Display values vs runtime values

There is a deliberate, documented split between the numbers used in computation and the numbers shown in UI strings:

export const DISPLAY = Object.freeze({
  F_H_HZ: 1.287,        // rounded HulyaPulse frequency, for display
  TAU_ZQ_S: 0.777,      // rounded Zeqond period, for display
  ALPHA_K: 0.00129,     // the published Zeq-paper α (≈ 1.29 × 10⁻³)
  ALPHA_K_RUNTIME: 0.001,
  KERNEL_VERSION: "1.287.5",
});

Two things to note, because they look like contradictions and are not:

• f_H displays as 1.287 Hz but computes as 1.287000000001287 Hz. The display value is the rounded representation; the runtime value is the exact rational. They are not algebraically equal, and the code says so explicitly.
• α is 10⁻³ at runtime but 1.29 × 10⁻³ in the published equation. These are two different quantities that happen to share a name. The runtime ALPHA_K = 10⁻³ is the coefficient that makes the modulation bounded by construction to 0.1%. The display 0.00129 is the value printed in the Zeq paper's symbolic R(t) equation, preserved for continuity with the literature. A third, separate, unrelated α_econ = 1.29 × 10⁻³ lives in the economy config — never conflate it with either of these.

The precision bound is built into α

ALPHA_K = 10⁻³ is not enforced by a runtime guard that clamps a wandering value. It is chosen so that the modulation term α·sin(2π·f_H·t) can never exceed 0.1% in magnitude, because |sin| ≤ 1 and α = 10⁻³. The ≤0.1% precision bound that the VERIFY step checks is therefore a property of the constant itself, not a check that can fail silently. This is why the framework can promise a bound rather than hope for one.

Read next

• The MI Kernel — how these constants are served and announced
• The pipeline — where the constants enter the computation
• Synchronisation — τ and f_H as the clock

1 Zeqond = 0.777 s is the anchor most people remember. The exact integer behind it, 777,000,777 ns, is the one the framework computes with.