The prover advantage
To prove a computation in zero knowledge, you turn it into arithmetic constraints; fewer constraints means a faster, cheaper proof. Coherence's fixed-point-native proof gate needs about half as many as a generic field prover for the same truncating multiply, and not by cutting corners: the generic prover must range-check both operands inside the circuit to stay sound, while Coherence gets that bound as a compile-time language invariant and skips it. Here is the exact head-to-head, computed live. Set the size of the computation and watch the counts.
A computation of n fixed-point multiplies (plus the sums that chain them). Both provers prove the same truncating-multiply gate; only the operand-bound handling differs.
What this proves: the exact constraint-count accounting from the reference,
coherence_proof/fixedpoint_advantage.cl (gate_cost_native / gate_cost_generic),
computed live. The saving is real and load-bearing: the two operand range-checks the generic prover carries
are necessary for its soundness, and Coherence removes the need for them at compile time, not in the proof.
What it does not prove: this counts constraints, the dominant cost of a proof; wall-clock proving time
also depends on the backend. It is the head-to-head from the fabric, not a benchmark of a specific machine.
Everything runs locally: no server, no external script. The counts are the same integer formulas you can read in this page's source. See the proofs in action · Back to demos