Skip to main content

The ZEQOND_RECEIPT

Every computation returns a ZEQOND_RECEIPT alongside its value. The receipt attests two things, both keyed to the 1.287 Hz HulyaPulse clock:

  1. the Zeqond-averaged standard-physics value — the ordinary-physics number you would quote in a paper, recovered from the modulated tick value; and
  2. the continuum state fields the experiment actually produced — temperature, stress, velocity, potential, and so on.

It is the same object the envelope and the state-detail page render, so what an API caller receives is byte-for-byte what the certificate shows.

The honesty rule is non-negotiable. A field appears in the receipt only when the computation genuinely produced it. A kinetic-energy compute has no strain or temperature field, so those are simply absent — never a fabricated zero, never a placeholder. This is the honesty contract applied to state fields.

The Zeqond-averaged recovery​

The framework's carrier is R(t) = S(t)·[1 + α·sin(2π·1.287·t)], with α ≈ 1.29×10⁻³. Averaged over one Zeqond (0.777000777 s, exactly one full period) the α·sin term integrates to zero, so ⟨R⟩ = S(t) exactly. S(t) is the standard-physics value; the reported tick value differs from it by at most α. This is an identity, not a fit — it holds for an RK4-integrated value the same way it holds for a closed-form one.

"zeqond_averaged": {
  "standard_physics_value": 8670.9391,
  "unit": "N",
  "averaging_window_s": 0.777000777,
  "pulse_hz": 1.287,
  "note": "R(t)=S(t)·[1+α·sin(2π·1.287·t)] averaged over one Zeqond (0.777 s) recovers S(t) …"
}

The full schema​

The schema below is the complete vocabulary. Each compute fills only the subset it computed; the rest are absent.

ZEQOND_RECEIPT:
  pulse_frequency: "1.287 Hz"
  time_unit: "0.777000777 s (1 Zeqond)"
  state_fields:
    temperature_field:      T(x)
    displacement_field:     u(x)
    strain_field:           ε(x)
    stress_field:           σ(x)
    velocity_field:         v(x)
    pressure_field:         p(x)
    potential_field:        φ(x)
    internal_energy_field:  e_in(x)
    entropy_field:          s(x)
    heat_flux_vector:       q(x)
    electromagnetic_vectors: [E(x), B(x), P(x), M(x)]
    momentum_density:       π(x)
  material_and_response_fields:
    elasticity_tensor:        C(x)
    damage_degradation_field: D(x)
    viscosity_field:          μ(x)
  boundary_and_interaction_fields:
    boundary_traction:      t_bound(x)
    contact_constraint_flag: C_contact(x)
  fields_present: [ … ]      # the keys actually filled, in display order
  fields_absent_note: "Only fields this experiment actually computed are present …"
  verification: "HMAC_ZeqProof_Active"

How a field is chosen​

For a closed-form compute the field is read from the result's own SI unit — honest by construction, because the operator genuinely computed a value in that unit:

result unitreceipt field
Papressure_field
N/m²stress_field
m/svelocity_field
Vpotential_field
Telectromagnetic_vectors.B
V/melectromagnetic_vectors.E
kg·m/smomentum_density
K / °Ctemperature_field
J/Kentropy_field
W/m²heat_flux_vector
Pa·sviscosity_field

Units whose meaning is ambiguous — J (kinetic? potential? internal? field energy?) and bare m (length? radius? wavelength? displacement?) — map to no field. Auto-labelling them would mislabel, so a compute that returns joules carries no state field unless the route computes one explicitly. The RK4 solvers (/solve, /multibody) pass their real fields (internal_energy_field, momentum_density) directly rather than guessing.

Where you get it back​

The receipt is returned in the payload of every computation endpoint, and is surfaced on every client.

REST — /api/zeq/compute, /api/zeq/solve, /api/zeq/multibody​

POST /api/zeq/compute
{ "domain":"newtonian", "operators":["KO42","NM21"],
  "inputs":{ "m1":5.972e24, "m2":1000, "r":6.78e6 } }

// → response (abridged)
{
  "value": 8670.9391, "unit": "N", "zeqProof": "fc82403f…",
  "zeqond_averaged": { "standard_physics_value": 8670.9391, "unit": "N", "averaging_window_s": 0.777000777, "pulse_hz": 1.287 },
  "zeqond_receipt": {
    "pulse_frequency": "1.287 Hz",
    "time_unit": "0.777000777 s (1 Zeqond)",
    "state_fields": {}, "material_and_response_fields": {}, "boundary_and_interaction_fields": {},
    "fields_present": [],
    "fields_absent_note": "Only fields this experiment actually computed are present …",
    "verification": "HMAC_ZeqProof_Active"
  }
}

Gravitational force is in newtons — an ambiguous-for-continuum unit — so fields_present is empty here, honestly. A compute that returns pascals fills state_fields.pressure_field; an RK4 /solve fills state_fields.internal_energy_field.

MCP — zeq_compute, zeq_solve, zeq_multibody​

The receipt is in the tool's structuredContent (machine-readable, full precision) and summarised in the text block:

ZEQOND_RECEIPT
──────────────
  pulse       : 1.287 Hz
  time unit   : 0.777000777 s (1 Zeqond)
  standard-Φ  : 8670.9391 N (Zeqond-averaged, 0.777 s window)
  fields      : none (this compute's unit denotes no continuum field — omitted, not fabricated)
  verification: HMAC_ZeqProof_Active
structuredContent: {
  "value": 8670.9391, "unit": "N",
  "zeqond_receipt": { … }, "zeqond_averaged": { … },
  "verify": { … }
}

CLI​

compute, solve and multibody print a standard-Φ row and a ZEQOND receipt row on the result card, straight from the payload.

Python SDK​

client.compute(...) returns the full JSON envelope, so resp["zeqond_receipt"] and resp["zeqond_averaged"] are already there — no extra call.