QCNEWS
AlchemQ is a quantum circuit optimizer that ships an open, machine checkable certificate with every rewrite, so a verifier can confirm the new circuit still does the same work as the original.
A new quantum circuit optimizer called AlchemQ ships every rewritten circuit with a small, machine-checkable proof that the new circuit still computes the same thing as the original. The proof is tamper-evident, version-stamped, and open: anyone can run the reference verifier without trusting the optimizer. The argument is not about raw speed.
A quantum optimizer that reorders, compresses, or re-encodes a circuit can change what it does in ways that look fine in code, and a hardware run will only confirm that something ran, not that the right thing ran. AlchemQ treats this as a verification problem. Each certificate carries three things: a canonical hash of the input and output circuits, a measured numeric residual showing how close the two are up to a global phase, and a tri-state verdict: certified, rejected, or inconclusive. The schema is versioned, so old certificates can be checked against older rules, and the whole package is self-contained.
The benchmark numbers favor the open baseline in the average case. AlchemQ's own paper runs against PyZX, a strong open-source circuit optimizer. PyZX already cuts the T-count (a count of an expensive two-qubit gate family) by 21.4% on average across 82 of 100 standard benchmark circuits. AlchemQ is strictly better than PyZX on only 9 of those 100 instances. On the full 400-optimization run, every returned circuit is certified, every injected mutation is detected, and a 2,998-test suite passes on two platforms, but PyZX is competitive, and the new tool wins by a thin margin in the average case.
The aggregation across three fuzzy t-norms (membership functions used to score which candidate rewrites count as "best") returns identical circuits on all 100 standard instances and only diverges on 4 of 38 adversarial ones. The practical value of carrying three t-norms in the standard regime is, by the paper's own numbers, mostly vestigial. The certifier is supposed to surface that kind of thing, and it did.
The certifier caught two upstream bugs in the standard workflow. The first was a false negative in PyZX's own compare_tensors routine, traced to a pivot-normalization step that left a residual of 4.7e-9 when the optimal overlap check expected 7.4e-11. The second was eight rejected certificates on macOS, traced to non-determinism in macOS's BLAS (basic linear algebra subprograms) library leaking into the phase-tracking field. Both bugs originated outside the optimizer, both were reproducible, and the artifact sets validate 400 out of 400 on both platforms after the fixes. The certifier's design held; the dependencies did not.
On IBM's Heron r2 processor, a current-generation superconducting quantum chip, the certified AlchemQ circuit ran 78% shallower with 65% fewer two-qubit gates than the baseline. On all three output-quality metrics, the AlchemQ run came out ahead. At 1,024 shots, the difference is not statistically significant. The result is a real win in depth and gate count, and a provisional one in fidelity, and the paper says so plainly.
The AlchemQ release ships the certificate specification and a standalone reference verifier (Apache-2.0) as open source, with the test data and scripts. The optimization engine itself is not. A reader can verify any circuit AlchemQ produces, down to the numeric residual, without trusting the authors. They can't reproduce the optimization pipeline end to end on their own machine. For a tool whose entire argument is that quantum rewrites should be auditable, leaving the audit open while keeping the producer closed is a narrower commitment than the pitch suggests.
The next test is whether other groups run the verifier on independent inputs. The Apache-2.0 reference is a real invitation; the proprietary engine is the part that still has to be taken on trust.