zcc-verify

Independent consistency checker for ZKSF certificates: ZCC-v0.1 and ZHF-v0.1 accuracy certificates, ZCC-Estimate-v0.1/v0.2 estimates and ZQEC-v0.1 error-correction certificates.

No dependencies. Python 3.10+.

pip install zcc-verify
zcc-verify fe529e21d7404ff3

certificate fe529e21d7404ff3 (ZCC-v0.1)
  [ok  ] required fields present
  [ok  ] protocol recognised: ZCC-v0.1
  [ok  ] carries no account or circuit data
  [ok  ] circuit identified by SHA-256
  [ok  ] issued-at timestamp parses: 2026-07-09T13:20:03+00:00
  [ok  ] shot count: 512
  [ok  ] measured outcomes: 2 outcomes, 512 shots shown
  [ok  ] bound is a probability: 2.1073424255447017e-08
  [ok  ] bound recomputed from the measurement: sqrt(2 x 2.22045e-16) = 2.10734e-08
  [ok  ] converged flag consistent with the bound: True
  consistent: the stated bound follows from the stated measurement

Exit status is 0 when every check passes and 1 when any fails, so it drops into CI.

Why this exists

Classical simulation of quantum circuits is exact only in a narrow regime. Exact statevector methods terminate near 30 to 32 qubits, because state size grows as 2^n. Beyond that every practical method is approximate: tensor networks truncate the bond dimension, Pauli propagation truncates operator weight, and real hardware substitutes device noise for the ideal distribution.

An approximate result without an error statement is not a measurement, it is an assertion. ZCC-v0.1 and ZHF-v0.1, and ZCC-Estimate and ZQEC-v0.1 after them, are small versioned protocols that attach a machine-checkable accuracy statement to a result. This tool is the checker: it takes a certificate and confirms the claim it makes follows from the measurement it reports.

The protocols are specified in a citable paper:

Reporting the Accuracy of Approximate Quantum Circuit Simulation: A Machine-Checkable Certificate Format. doi.org/10.5281/zenodo.21851381

What this establishes

The load-bearing check recomputes the declared bound from the measured quantity the certificate itself reports, and requires the two to agree:

It also checks that the record is well formed, that the converged flag agrees with the bound (the two methods use different thresholds), that outcome counts do not exceed the shot count, and that no account data or circuit source is present.

A certificate whose stated bound does not follow from its own stated inputs fails here, whoever issued it.

What this does not establish

It does not establish that the measurement was honest. The discarded weight in a tensor-network certificate, and the coefficient mass in a Pauli one, are produced by whoever ran the simulation. No arithmetic on the record can confirm that the number reported is the number that was measured. The same holds for the failure counts in an error-correction certificate and the energy in a neural one.

Verifying a certificate is not the same as trusting the issuer. What it gives you is narrower and still worth having: the claim is well formed, self-consistent, and stated in a form somebody else can check.

Use as a library

from zcc_verify import fetch, verify

report = verify(fetch("df1d4c698a954051"))
print(report.ok)                          # True
print([c.name for c in report.failures])  # []

fetch() reads the public record at https://api.zksf.org/certify/<id>/json. It needs no authentication and no account. verify() takes a plain dict, so a record from any source, including a local file or a different issuer, can be checked:

zcc-verify ./certificate.json

Live certificates to try, one for every kind of statement the four protocols make:

On the limits of the bound

The certified bound is an empirical result rather than a theorem. It held across 334 runs at sizes where the exact answer is computable, 290 of them constructed specifically to break it, approaching at closest 49 percent of its value. Above 20 qubits it cannot be checked by direct comparison and no such evidence exists. Where a hard ceiling is required, use an exact or stabilizer engine.

The paper is explicit about the case in which the motivating derivation does not extend: in deep sequential circuits the accumulated truncation weight has been measured understating the true infidelity by up to a factor of seven. It also shows, by explicit counterexample, that a natural tightening of the bound is unsound.

Where these certificates come from

ZKSF (Zero Kelvin Simulation Foundry) runs quantum circuits on classical simulators, GPU accelerators, or real quantum processors, and attaches one of these accuracy statements to every approximate result.

• Python SDK — qsim-sdk on PyPI, source at official-dvl/zksf, DOI 10.5281/zenodo.21836619. Accepts Qiskit circuits directly, and Cirq, PennyLane, pyQuil or Braket circuits via an optional transpiler.
• Try it without an account — the Colab quickstart reads real completed certificates from the public API before it asks you for anything.
• Android app — submit a circuit and read the result from a phone, including runs on real quantum hardware: Google Play.
• Protocol reference — CERTIFICATION.md
• Documentation — zksf.org/docs

This checker is deliberately independent of all of the above: it has no dependency on the SDK, needs no account, and will check a certificate issued by anyone who emits the format.

Licence

MIT.