PropHunt: Automated Optimization of Quantum Syndrome Measurement Circuits

Joshua Viszlai, Satvik Maurya, Swamit Tannu, Margaret Martonosi and Frederic T. Chong

Quantum error correction repeatedly runs a "syndrome measurement" circuit — a mesh of CNOT gates that checks the parity of qubits to spot errors — and the exact order of those gates decides how a single glitch spreads and whether the code can still correct it; existing tools optimize the wrong thing (gate count or depth), so this paper (Chicago, Wisconsin, Princeton — Joshua Viszlai, Frederic Chong, and colleagues) presents PropHunt, which tunes the gate order per-CNOT to directly minimize the logical error rate, cutting it 2.5 to 4 times and matching hand-designed circuits automatically.

The argument in one glance

Problem

The circuit that checks for quantum errors can itself spread them

Fault-tolerant quantum computing relies on quantum error correction (QEC): a logical qubit is encoded across many physical qubits, and the machine repeatedly checks for errors and corrects them so a computation can run longer than any physical qubit stays reliable. Those checks are parity checks (stabilizers) — the hardware measures whether groups of data qubits have an even or odd number of errors, producing "syndrome" information that reveals where errors are without disturbing the encoded data. Each round of checking is done by a Syndrome Measurement (SM) circuit: a physical circuit of CNOT gates between data qubits and helper (ancilla) qubits, plus measurements. These SM circuits are run over and over throughout the entire program, and they define the code's logical error rate — how often, despite correction, a logical error slips through. So their quality is decisive for the whole system. The subtle danger is that the SM circuit is itself made of noisy gates, and errors inside it propagate: a single fault on an ancilla qubit can spread through the CNOTs to several data qubits at once (a "hook error"), making one physical fault look like many and potentially defeating the code with fewer errors than it was designed to tolerate. How the CNOTs are ordered determines how errors spread, and therefore how well the code actually works.
What people did

Optimize SM circuits for gate depth or gate count

The natural approach is to reuse the circuit-optimization tools built for the noisy quantum computers of today (the NISQ era). Those tools take a circuit and reduce its gate depth (how many time steps it takes) or its gate count (how many gates it uses), on the sensible logic that fewer and shorter gates mean fewer chances for any error to occur at all. Applied to an SM circuit, they try to make it shallower and smaller, treating it like any other circuit to be compressed. Hand-designed SM circuits for well-known codes like the surface code exist, but generating good ones for arbitrary codes is left to experts.
Why it fell short

Depth and count are the wrong target for a syndrome circuit

Optimizing gate depth or count is optimizing a proxy that does not capture what actually determines an SM circuit's quality. The real quantity is the logical error rate, and that is set not by how many gates there are but by how errors propagate through them — specifically, by whether hook errors from ancilla faults line up with the code's logical operators and thereby reduce the effective code distance (the number of physical faults it truly takes to cause an undetected logical error). Two SM circuits with identical depth, or identical effective distance, can have very different real performance, because those metrics are imperfect predictors: a circuit can be shallower yet worse, or deeper yet better. NISQ-era tools do not model this error propagation at all, and they also ignore SM-specific constraints — the CNOTs must be ordered to preserve the code's stabilizer structure. On top of that the design space is huge: a distance-11 surface code SM circuit uses hundreds of qubits and gates, and general optimizers cannot navigate it under the propagation and commutation constraints. So the field had hand-designed circuits for a few codes and no general, automated way to build SM circuits that directly minimize logical error rate — leaving open how well many promising new QEC codes would actually perform.
This paper's idea

Tune the gate order to directly minimize logical error rate

PropHunt is an automated tool that optimizes SM circuits for CSS codes (a broad class of QEC codes) by targeting the thing that matters — the logical error rate — rather than a proxy. It works at the granularity of individual CNOT gates, exploring a fuller design space than coarser methods, and it navigates that large space efficiently through a key idea the authors call minimizing "ambiguity." Ambiguity captures when the pattern of syndromes produced by low-weight error combinations is confusable, which is what drives up the logical error rate; PropHunt introduces a novel way to find the minimum-weight logical errors in a circuit-level decoding graph, letting it identify exactly how errors propagate and then reorder gates to reduce that ambiguity and raise the effective distance. Because it optimizes the true objective, PropHunt iteratively improves an SM circuit's performance and can automatically recover the performance of expert hand-designed circuits — for surface codes it rediscovers the good designs on its own. On newer codes where no hand designs exist — specific Lifted Product and Random Quantum Tanner codes — it reduces logical error rates by 2.5 to 4 times compared with a standard circuit at a physical error rate of 0.1 percent. And because PropHunt gives fine-grained control over logical error rate, the authors build a near-term application, Hook-ZNE, that uses PropHunt's intermediate circuits as low-overhead error-mitigation gadgets for Zero-Noise Extrapolation, reducing error by 3 to 6 times over an existing QEC-plus-ZNE approach.

Why this problem is worth solving

Syndrome measurement is the beating heart of fault-tolerant quantum computing, so its efficiency directly bounds how well any error-correcting code performs.

Every fault-tolerant quantum program is, underneath, a loop that keeps measuring syndromes and correcting errors, round after round, for the entire computation. The SM circuit is what runs in that loop, so its quality is multiplied across the whole program: a slightly worse SM circuit means a higher logical error rate every single round, which compounds into needing more physical qubits, more time, or a larger code to reach a target reliability — all of which are brutally expensive on real quantum hardware. Meanwhile, the field is generating a flood of new QEC code designs, many of them promising far better efficiency than the surface code in theory. But a code’s theoretical promise only becomes real once it is compiled into an actual SM circuit, and if that compilation is done poorly the code will underperform its potential. Without a general, automated way to build good SM circuits, evaluating and deploying these new codes is stuck: you cannot tell how well a code will really do, and you cannot get the best out of it. A tool that automatically produces SM circuits which directly minimize logical error rate therefore unlocks both better performance from known codes and honest evaluation of new ones, acting on one of the most-repeated and most-consequential operations in the entire fault-tolerant stack.

The core realization is that the standard optimization targets miss the actual physics, and the right objective is error propagation itself.

The intuition behind minimizing gate count or depth is not crazy — fewer gates do mean fewer opportunities for an error to appear. But in an error-correcting circuit the question is not only whether an error appears; it is what an error does once it appears. Because the SM circuit deliberately entangles ancilla and data qubits through CNOTs, an error on one qubit can spread to others, and whether that spread is harmless or catastrophic depends entirely on the order of the gates. A single ancilla fault that hooks onto several data qubits in just the wrong pattern can imitate a logical error using far fewer physical faults than the code should require, silently gutting its protection — and a shallower circuit can make this worse, not better. So depth and count are imperfect predictors: they measure the chance of an error, not the consequence of one. PropHunt’s insight is to optimize the consequence directly, by modeling how every possible low-weight error propagates to syndromes and finding the gate orderings that keep dangerous errors distinguishable and non-overlapping with logical operators. Reframing SM-circuit optimization from “make the circuit small” to “make errors propagate safely” is what lets an automated tool actually improve the logical error rate rather than a stand-in for it.

What people did before, and where it broke

Optimize SM circuits for gate depth. Make the circuit shallower to reduce error opportunities. Where it broke. Depth is an imperfect predictor of logical error rate; a shallower circuit can propagate errors worse and perform worse.
Optimize SM circuits for gate count. Use fewer gates for the same reason. Where it broke. Like depth, count measures the chance an error occurs, not what it does — it ignores how ancilla faults hook onto data qubits.
Use general NISQ-era circuit optimizers. Apply standard physical-circuit optimization tools. Where it broke. They do not model error propagation and ignore SM-specific CNOT-ordering constraints needed to preserve the code’s stabilizer structure.
Hand-design SM circuits per code. Have experts craft circuits for specific codes like the surface code. Where it broke. It does not scale to the flood of new codes, and the design space (hundreds of qubits and gates) is too large to explore by hand.
The gap. No general, automated tool optimized SM circuits by directly minimizing logical error rate — modeling error propagation at the level of individual CNOTs — leaving new QEC codes’ real-world performance unknown and unoptimized.

How PropHunt works

From optimizing gate count to optimizing how errors propagate

↓ →
new
↓ →
new
↓ →
new
↓ →
new
↓ →
new

The idea

Optimize the true error behavior, not a convenient proxy. PropHunt targets the logical error rate directly by modeling how errors propagate through the SM circuit, instead of minimizing gate depth or count that only bound the chance an error appears. Designing an error-correction mechanism around the actual structure and behavior of errors, rather than a pessimistic or coarse stand-in, is the same principle the work on better-than-worst-case decoding for quantum error correction (better-than-worst-case decoding) covered elsewhere on this site is built on, extracting performance by reasoning about real error patterns rather than a proxy. PropHunt applies this at circuit-construction time, choosing gate orders that make errors propagate safely.

Automatically synthesize the QEC circuit for any code. Rather than relying on experts to hand-craft SM circuits per code, PropHunt is a general, automated tool that searches the per-CNOT design space to build good circuits for arbitrary CSS codes. Turning the expert, manual construction of a quantum-error-correcting code’s physical realization into an automated synthesis problem is the same enterprise the work on a layout synthesizer for quantum error-correction codes (QECC-Synth) covered elsewhere on this site pursues, generating code implementations automatically instead of by hand. PropHunt automates the SM-circuit half of that realization, directly optimizing for logical error rate.

Reuse the fine-grained control to mitigate errors, not just correct them. Because PropHunt can tune logical error rate precisely, its intermediate circuits double as low-overhead gadgets for Zero-Noise Extrapolation, a near-term error-mitigation strategy (Hook-ZNE). Squeezing better results out of noisy quantum hardware by tailoring a mitigation technique to the specific error behavior of the system is the same goal the work on application-tailored measurement error mitigation (VarSaw) covered elsewhere on this site shares, reducing error through careful, targeted mitigation. Hook-ZNE uses PropHunt’s controllable circuits to make ZNE cheaper and more effective than a standard QEC-plus-ZNE approach.

Following an SM circuit through PropHunt

Optimizing a syndrome measurement circuit

A trace, drawn from the paper, of how PropHunt improves an SM circuit by reordering CNOTs.

Step 1 of 5

Start from an SM circuit for a code

PropHunt takes a CSS code and an initial syndrome measurement circuit — a schedule of CNOT gates between data and ancilla qubits that implements the code's parity checks — as its starting point.

For a distance-11 surface code this is hundreds of qubits and gates.

Why it works

Logical error rate is set by propagation, not gate count. Fewer gates only reduce the chance an error appears → but the damage depends on how a fault spreads through the CNOTs → so optimizing propagation targets what actually determines performance.
Modeling propagation exposes the dangerous errors. You cannot fix what you cannot see → but statically propagating every low-weight error to its syndrome and finding min-weight logical errors → so PropHunt identifies exactly which patterns undermine the effective distance.
Per-CNOT granularity opens the real design space. Coarse edits miss good circuits → but tuning the schedule one CNOT at a time → so PropHunt explores orderings that keep hook errors from overlapping logical operators.
Minimizing ambiguity directly lowers logical error rate. Optimizing a proxy can move the wrong way → but using ambiguity, tied to confusable low-weight errors, as the objective → so each reordering provably targets the true metric.
Fine-grained control transfers to error mitigation. A tool that only corrects errors would stop there → but precise control over logical error rate yields tunable circuits → so intermediate designs become effective Zero-Noise Extrapolation gadgets in Hook-ZNE.

What it costs (trade-offs and scope)

It is specific to CSS codes. PropHunt optimizes SM circuits for CSS codes, a broad but not universal class; codes outside that structure are outside its stated scope.
The optimization is a search, guided by a model. PropHunt iteratively analyzes propagation and reorders gates; it improves circuits and recovers hand designs, but it is a heuristic search over a large space rather than a closed-form optimum, and its cost grows with code size.
Its benefits assume the circuit-level error model. The gains come from optimizing against a circuit-level model of how Pauli errors propagate; the real-world benefit tracks how well that model matches the hardware’s actual noise.
Hook-ZNE is a near-term add-on, not the main result. The error-mitigation application shows the value of fine-grained control, but it targets today’s noisy machines; the core contribution is optimizing SM circuits for fault-tolerant codes.
Reported figures are on specific codes and conditions. The 2.5-to-4-times logical-error-rate reduction and the 3-to-6-times Hook-ZNE improvement are measured on particular codes (surface, Lifted Product, Random Quantum Tanner) at specific physical error rates against specific baselines; results elsewhere may differ.

The comparison

Optimizing a quantum syndrome measurement circuit

Property	Gate depth / count tools	Hand-designed circuits	PropHunt
Optimization target
Models error propagation
Granularity
Works on new codes
Result

A comparison of ways to build a quantum syndrome measurement circuit. Depth and gate-count tools optimize a proxy that ignores how errors propagate; hand-designed circuits target the right thing but exist only for a few codes. PropHunt automatically optimizes SM circuits for CSS codes by modeling error propagation at the level of individual CNOTs and minimizing ambiguity, directly lowering logical error rate — recovering hand designs and cutting logical error rate 2.5 to 4 times on new codes. Exact figures should be read from the paper.Underlined values explain themselves when clicked.

Where this stops working

What to keep in mind

This explainer is based on the paper’s full text (the authors’ arXiv copy, 2601.17580, of the ASPLOS 2026 paper). The described system is the paper’s: PropHunt is an automated tool for optimizing Syndrome Measurement (SM) circuits for CSS quantum error-correcting codes. Its central point is that SM-circuit performance is determined by how errors propagate through the circuit (including hook errors, where an ancilla fault spreads to multiple data qubits via CNOT error-propagation rules and can reduce the effective code distance), which NISQ-era tools that optimize gate depth or count do not model. PropHunt optimizes at the granularity of individual CNOTs, uses a circuit-level decoding-graph model with a novel method for finding minimum-weight logical errors, and minimizes “ambiguity” to directly target the logical error rate. The paper reports PropHunt recovers hand-designed surface-code circuits automatically and reduces logical error rates by 2.5 to 4 times on specific Lifted Product and Random Quantum Tanner codes versus a standard coloration circuit at a 0.1 percent physical error rate; it also proposes Hook-ZNE, using intermediate circuits as low-overhead Zero-Noise Extrapolation error-mitigation gadgets, reporting a 3 to 6 times error reduction over a Distance-Scaling ZNE baseline. The background above on QEC, stabilizers, syndrome measurement, CNOT error propagation, hook errors, and effective code distance is standard context provided to make the approach intuitive. The step-by-step walkthrough is an illustration of the described mechanism. Exact algorithm details, the ambiguity formulation, and the full evaluation should be read from the paper.

Background

Why fault-tolerant quantum computing is as much a compilation problem as a physics one

It helps to see PropHunt within a broad realization about fault-tolerant quantum computing: the promise of quantum error correction is not delivered by codes on paper but by the entire software-and-compilation stack that turns those codes into physical operations on real, noisy hardware. A code specifies which parities to check; a compiler must turn that into an actual circuit of gates, a decoder must turn the measured syndromes back into corrections, and a scheduler must fit it all onto a device in real time. At every stage, choices that look like mere implementation details — the order of gates, the structure of the decoder, the layout on the chip — turn out to determine whether the code reaches its theoretical error-correcting power or falls far short. The field keeps finding that these stages must be co-designed with the codes’ actual error behavior, not treated as generic. PropHunt is a clean instance at the circuit-construction stage: it shows that optimizing the SM circuit for how errors propagate, rather than for generic gate metrics, is what recovers a code’s real performance. The broader effort it belongs to — building the practical machinery that lets error correction actually run and keep up on hardware — is the same terrain the work on extending the reach of real-time quantum error correction (Promatch) covered elsewhere on this site occupies, making the syndrome-processing side fast enough to be usable. PropHunt’s particular contribution is to automate and directly optimize the circuit that produces the syndromes in the first place, closing a gap that left new QEC codes’ real-world performance unknown.

If you remember only three things

1. Fault-tolerant quantum computing repeatedly runs Syndrome Measurement (SM) circuits — meshes of CNOT gates that measure parity checks on qubits to detect errors without disturbing the encoded data. These circuits define a code's logical error rate and run constantly, so their quality is decisive. The catch is that the SM circuit is itself noisy, and errors propagate through it: a single ancilla fault can hook onto several data qubits via the CNOTs, imitating a multi-qubit error and reducing the effective code distance, so the code can fail with fewer faults than intended. How the CNOTs are ordered determines this spread. But existing (NISQ-era) circuit optimizers minimize gate depth or count — a proxy for the chance an error occurs — which does not model propagation and is an imperfect predictor: a shallower circuit can be worse, a deeper one better.
2. PropHunt is an automated tool that optimizes SM circuits for CSS codes by targeting the logical error rate directly. It works at the granularity of individual CNOTs, builds a circuit-level decoding-graph model that propagates every low-weight error to the syndromes it flips, and introduces a novel method to find the minimum-weight logical errors — the dangerous patterns. It then minimizes a quantity the authors call "ambiguity" (confusable low-weight error combinations that drive up logical error rate), reordering gates to keep hook errors from overlapping logical operators and to raise the effective distance, all while preserving the code's stabilizer structure. Because it optimizes the true objective, it iteratively improves circuits and automatically recovers expert hand-designed surface-code circuits.
3. On newer codes with no hand designs — specific Lifted Product and Random Quantum Tanner codes — PropHunt reduces logical error rates by 2.5 to 4 times versus a standard circuit at a 0.1 percent physical error rate. Its fine-grained control over logical error rate also enables a near-term application, Hook-ZNE, which uses PropHunt's intermediate circuits as low-overhead Zero-Noise Extrapolation error-mitigation gadgets, reducing error 3 to 6 times over an existing QEC-plus-ZNE approach. The trade-offs and scope: it is specific to CSS codes, it is a model-guided heuristic search whose cost grows with code size, its benefits track how well the circuit-level error model matches real hardware noise, and the figures are on specific codes and baselines. This explainer is based on the paper's full text.

Check yourself

Check your understanding

1. Why does the order of CNOT gates in a syndrome measurement circuit matter so much?
2. Why are gate depth and gate count the wrong optimization targets for SM circuits?
3. How does PropHunt optimize an SM circuit, and what is "ambiguity"?
4. What does PropHunt achieve, and what are the limits of the approach?

Sources

The paper is “PropHunt: Automated Optimization of Quantum Syndrome Measurement Circuits” by Joshua Viszlai, Satvik Maurya, Swamit Tannu, Margaret Martonosi, and Frederic T. Chong (University of Chicago, University of Wisconsin-Madison, and Princeton University), published at ASPLOS 2026, DOI 10.1145/3779212.3790205. It is available on arXiv as 2601.17580.

This explainer is written from the paper’s full text (the authors’ arXiv copy). PropHunt is an automated tool for optimizing Syndrome Measurement circuits for CSS quantum error-correcting codes by directly minimizing logical error rate. It optimizes at the granularity of individual CNOTs, models how errors propagate using a circuit-level decoding graph with a novel minimum-weight-logical-error method, and minimizes “ambiguity” to raise the effective code distance — recovering hand-designed circuits automatically and reducing logical error rates 2.5 to 4 times on Lifted Product and Random Quantum Tanner codes at a 0.1 percent physical error rate. It also introduces Hook-ZNE, using intermediate circuits as Zero-Noise Extrapolation error-mitigation gadgets, reducing error 3 to 6 times over a Distance-Scaling ZNE baseline. Background on quantum error correction, syndrome measurement, hook errors, and effective code distance is standard context. The numbers are the paper’s own; exact mechanisms and full results should be confirmed in the paper.