AlphaSyndrome: Tackling the Syndrome Measurement Circuit Scheduling Problem for QEC Codes

Yuhao Liu, Shuohao Ping, Junyu Zhou, Ethan Decker, Justin Kalloor, Mathias Weiden and 5 others

Quantum error correction keeps a quantum computer reliable by constantly running syndrome-measurement cycles — checking parity operators called stabilizers to spot errors without disturbing the data — and these cycles dominate the machine's cost; because the stabilizers commute, they can be measured in many valid orders, but each order routes a single fault to different data qubits, so the schedule quietly changes the logical error rate by a lot, and good schedules were known only for the surface code; this paper (University of Pennsylvania, IBM, and collaborators — Yuhao Liu, Gushu Li, and colleagues) presents AlphaSyndrome, which automatically searches schedules with Monte Carlo Tree Search, using noisy simulation and the real decoder to steer faults away from logical operators and into what the decoder can fix — cutting logical error rates by 80.6 percent on average versus depth-optimal schedules, matching Google's hand-tuned surface-code schedule, and beating IBM's schedule for the Bivariate Bicycle code.

The argument in one glance

Problem

The order you measure error checks in secretly decides how reliable the machine is

A quantum computer is protected by quantum error correction (QEC): one logical qubit is encoded across many physical qubits, and the machine constantly runs syndrome-measurement cycles to catch errors. Each cycle measures a set of parity checks called stabilizers — using helper (ancilla) qubits and two-qubit gates — which reveal whether an error occurred without disturbing the encoded data, and a classical decoder then works out what error happened so it can be undone. These cycles run over and over and dominate the whole machine's spacetime and hardware cost. Here is the subtle part. The stabilizers commute, meaning they can be measured in many different valid orders, and it seems like the order should not matter. But it does, enormously. A single fault on an ancilla qubit in the middle of a measurement can spread to different data qubits depending on the order of the two-qubit gates — a so-called hook error. So different schedules route the same fault to different places, producing very different logical error rates. The order of the checks is not a free choice; it quietly determines reliability, and getting it wrong wastes the entire point of error correction.
What people did

Minimize circuit depth, and hand-craft schedules for the surface code

The usual approach is to pick a schedule that minimizes the circuit depth — do as many measurements in parallel and as few steps as possible — so each cycle runs fast. For the most studied code, the surface code, experts have also hand-crafted specific schedules known to keep errors well-behaved, and hardware teams at Google and IBM use such carefully designed orders.
Why it fell short

Depth is the wrong target, and hand-crafting does not scale to new codes

Optimizing for depth misses the real issue. A depth-optimal schedule runs quickly but pays no attention to where faults propagate, so it can route errors into patterns that the decoder cannot fix or that flip the encoded information, giving a much higher logical error rate than a slightly deeper but smarter schedule. Hand-crafting is not a general answer either: it took expert effort to find good surface-code schedules, and that effort does not transfer. The most promising newer codes — such as the qubit-efficient Bivariate Bicycle code — have far more complex stabilizer structures, and effective syndrome-measurement scheduling outside surface codes was largely unexplored. So the field faced a bind: the schedules that matter most for reliability were chosen by the wrong criterion (depth) or by scarce human expertise that only covered one code family. What was needed was an automatic way to find schedules that shape error propagation for reliability, for any commuting-stabilizer code and any decoder.
This paper's idea

Search schedules that steer faults away from danger, using the decoder as judge

AlphaSyndrome is an automated synthesis framework that schedules syndrome-measurement circuits for general commuting-stabilizer codes, assuming only that the stabilizers mutually commute and that some heuristic decoder is available. Its key observation is that scheduling should shape error propagation toward two goals: a fault should end up as an error pattern that is (i) not close to a logical operator — because errors near a logical operator can silently flip the encoded information — and (ii) within the decoder's correctable region, so the specific decoder in use can actually fix it. AlphaSyndrome therefore treats scheduling as an optimization problem over the order and parallelism of the two-qubit gates, and explores it with Monte Carlo Tree Search (MCTS), the same kind of guided search used in game-playing programs. It builds a search tree of partial schedules, and evaluates candidates not by depth but by running noisy simulations with the actual decoder in the loop, measuring the resulting logical error rate. Guided by the code structure and this decoder feedback, MCTS homes in on schedules that keep faults away from logical operators and inside what the decoder can correct. Across diverse code families, sizes, and decoders, AlphaSyndrome cuts logical error rates by 80.6 percent on average (up to 96.2 percent) versus depth-optimal baselines, automatically matches Google's hand-crafted surface-code schedules, and beats IBM's schedule for the Bivariate Bicycle code.

Why this problem is worth solving

Error correction is the tax every quantum computer must pay to be reliable, and the syndrome-measurement cycle is where most of that tax is collected.

Physical qubits are unavoidably noisy — they suffer decoherence, control imperfections, leakage, and measurement errors — so raw error rates pile up quickly as a circuit gets deeper. Quantum error correction fights this by encoding a single logical qubit into a structured, redundant group of physical qubits and continually detecting and removing errors without disturbing the encoded information. The detection step is the syndrome-measurement cycle: the machine measures a set of parity operators called stabilizers, each using an ancilla qubit and a sequence of two-qubit gates, which tells you whether an error occurred (the syndrome) while leaving the actual quantum state intact; a classical decoder then reads the syndrome and decides what error happened so it can be corrected. Because errors accumulate continuously, this cycle must run over and over, at high repetition, throughout the entire computation. As a result, syndrome-measurement cycles dominate the spacetime footprint and hardware cost of any error-corrected program. This is the machinery that lets logical error rates be suppressed — often exponentially with the code distance — provided physical error rates are low enough, so any architecture aiming at large, reliable quantum algorithms lives or dies by how well this cycle is implemented.

The trap is that the choice everyone treated as free — the order of the measurements — actually controls the logical error rate.

Stabilizers commute, which mathematically means they can be measured in any relative order and still give the same information, so it is tempting to treat the schedule as a mere performance knob and just minimize depth. But under realistic noise the order matters, because of how a single fault spreads. Each stabilizer is measured with a chain of two-qubit gates between an ancilla qubit and several data qubits. If an error strikes the ancilla partway through that chain, it propagates through the remaining gates onto multiple data qubits at once — this is called a hook error, a single fault turning into a multi-qubit error pattern. Crucially, which data qubits it reaches depends on the order of the gates, so two schedules that are logically equivalent produce different error patterns from the same fault. Some patterns are benign and easy for the decoder to correct; others land close to a logical operator, where they can flip the encoded information without being caught, or fall outside what the decoder can fix. That is why different schedules yield large variations in logical error rate. Minimizing depth ignores this entirely, and figuring out good schedules by hand only happened for the surface code, leaving the newer, more efficient codes — where the stabilizer structure is more tangled — without any principled way to schedule.

What people did before, and where it broke

Depth-optimal scheduling. Choose the order and parallelism that minimize circuit depth so each cycle is as fast as possible. Where it broke. Depth is the wrong objective for reliability: it ignores where faults propagate, so it can route errors into uncorrectable patterns or near logical operators, giving a much higher logical error rate than a smarter schedule.
Hand-crafted surface-code schedules (Google). Have experts design specific, well-behaved measurement orders for the surface code. Where it broke. It works only for the surface code and took scarce human expertise; the effort does not transfer to other codes with more complex stabilizer structure.
Manual schedules for new codes (IBM, Bivariate Bicycle). Hand-design a schedule for a specific promising non-surface code. Where it broke. It is a one-off, hard to get right, and there was no general method — effective scheduling outside surface codes was largely unexplored.
Ignore the decoder when scheduling. Pick a schedule without regard to which decoder will run. Where it broke. Different decoders can correct different error patterns, so a schedule good for one decoder may be poor for another; scheduling and decoding must be considered together.
The gap. No automated method found syndrome-measurement schedules that shape error propagation for reliability, generalizing across commuting-stabilizer codes and accounting for the specific decoder in use.

How AlphaSyndrome works

Searching for a schedule that shapes where faults land

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

The idea

Optimize for where errors go, not for how fast the cycle runs. The central reframing in AlphaSyndrome is that the schedule’s real job is to shape error propagation, steering faults into patterns that are far from logical operators and that the decoder can correct — not merely to minimize depth. Reliability, measured as logical error rate, becomes the objective. Choosing how error correction is carried out specifically to keep the effective error within what can be handled, rather than optimizing a proxy like speed, is the same instinct the work on extending the reach of real-time quantum error correction covered elsewhere on this site follows, treating the correctable outcome as the thing to protect. AlphaSyndrome applies that instinct to the measurement schedule itself, turning gate ordering into a reliability lever.

Search a vast discrete space with guided tree search. The number of valid schedules explodes with code size, far too many to enumerate, so AlphaSyndrome uses Monte Carlo Tree Search to explore orderings and parallelism intelligently, deepening promising branches while still sampling new ones. Attacking an enormous discrete configuration space for a quantum program by searching it in a guided, sampled way instead of exhaustively is the same strategy the work on a classical simulation bootstrap for variational quantum algorithms covered elsewhere on this site uses, navigating a huge space to find a high-quality point cheaply. AlphaSyndrome’s search is distinctive in that its scoring function is a noisy simulation with the real decoder, so it optimizes the true quantity of interest.

Exploit the code’s structure to schedule its measurements. AlphaSyndrome does not search blindly; it is guided by the code structure — the stabilizers and the logical operators — so it knows which error patterns are dangerous and where the correctable region lies. Using the algebraic structure of a quantum program to drive how its operations are compiled and ordered is the same principle the work on a generalized block-wise compiler optimization framework for quantum programs covered elsewhere on this site is built on, letting the structure of the operators dictate an efficient schedule. AlphaSyndrome extends that structure-aware compilation to the syndrome-measurement circuit, where the structure tells it how to keep faults away from logical operators.

Following a schedule search through AlphaSyndrome

Scheduling the measurement of one stabilizer to avoid a bad hook error

A trace, drawn from the paper, of how AlphaSyndrome chooses gate orderings that keep faults correctable.

Step 1 of 5

A stabilizer is measured by a chain of two-qubit gates

Consider measuring a stabilizer with an ancilla qubit and a sequence of two-qubit gates touching several data qubits. Because the stabilizers commute, this chain can be ordered in many equivalent ways, and a depth-optimal choice would just pick the fastest.

The ordering is a free choice mathematically, but not physically.

Why it works

The schedule controls error propagation, so it can be optimized for it. Commuting stabilizers admit many orders, and each routes a fault differently → so the resulting error pattern is a function of the schedule → so choosing the order can place faults where they are harmless.
Depth-optimal schedules leave reliability on the table. Minimizing depth ignores where faults land → so it can route them near logical operators or beyond the decoder → so optimizing instead for propagation cuts logical error rate by 80.6 percent on average over depth-optimal.
Scoring with the real decoder captures the true objective. Logical error rate depends on what the specific decoder can correct → but AlphaSyndrome evaluates schedules by noisy simulation with that decoder in the loop → so it optimizes actual reliability, not a proxy, and adapts to each decoder.
Guided tree search makes the huge space tractable. The number of valid schedules is enormous → but Monte Carlo Tree Search deepens promising orderings while sampling new ones → so it finds strong schedules without enumerating them all.
Structure generalizes the method beyond surface codes. Good schedules were hand-found only for surface codes → but guiding the search by any code’s stabilizer and logical-operator structure removes that limitation → so AlphaSyndrome matches expert surface-code schedules and beats hand-made ones for other codes.

What it costs (trade-offs and scope)

It may accept more depth for fewer errors. By optimizing logical error rate rather than depth, AlphaSyndrome can choose a slightly deeper schedule than the depth-optimal one; the trade is deliberate — modest extra time per cycle in exchange for a large drop in logical error rate — but it is a trade.
The search itself costs compute. Monte Carlo Tree Search with noisy simulation rollouts and a decoder in the loop is a substantial offline computation; this is paid once to synthesize a schedule that is then reused across the many rounds, but it is not free, and larger codes make the search harder.
Results are tied to the decoder and noise model assumed. Because scoring uses a specific heuristic decoder and noise model, a schedule optimized for one decoder or noise regime is not guaranteed optimal for another; the method must be re-run when those change (which is also why it is decoder-aware by design).
It assumes mutually commuting stabilizers and a heuristic decoder. The framework targets general commuting-stabilizer codes with a heuristic decoder; codes or settings outside those minimal assumptions fall outside its stated scope.
It optimizes the schedule, not the code or hardware. AlphaSyndrome improves how a given code’s syndrome measurements are ordered; it does not change the code’s qubit overhead or the underlying hardware, so it composes with, rather than replaces, better codes and devices.

The evaluation

Choosing a syndrome-measurement schedule

Property	Depth-optimal schedule	Hand-crafted (expert)	AlphaSyndrome
Objective optimized
Accounts for the decoder
Works beyond surface codes
Logical error rate
On known expert schedules

A comparison of syndrome-measurement scheduling. AlphaSyndrome optimizes logical error rate with the decoder in the loop, cutting it by 80.6 percent on average (up to 96.2 percent) versus depth-optimal schedules, automatically matching Google's hand-crafted surface-code schedule and outperforming IBM's schedule for the Bivariate Bicycle code.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 (arXiv:2601.12509). The mechanism described is the paper’s: AlphaSyndrome is an automated synthesis framework for scheduling syndrome-measurement circuits in general commuting-stabilizer codes, assuming only mutually commuting stabilizers and a heuristic decoder. It formulates scheduling as an optimization problem that shapes error propagation to (i) avoid patterns close to logical operators and (ii) remain within the decoder’s correctable region, and it uses Monte Carlo Tree Search to explore ordering and parallelism, guided by code structure and by decoder feedback from noisy simulation rollouts with the decoder in the loop. The reported results are that, across diverse code families, sizes, and decoders, it reduces logical error rates by 80.6 percent on average (up to 96.2 percent) relative to depth-optimal baselines, matches Google’s hand-crafted surface-code schedules, and outperforms IBM’s schedule for the Bivariate Bicycle code. Exact search parameters, the noise models and decoders used, the code families evaluated, and full results should be read from the paper.

Background

Why quantum error correction is becoming a compiler problem

It helps to see AlphaSyndrome as part of a shift in how fault-tolerant quantum computing is being built: increasingly, the hard problems are not only in physics and coding theory but in compilation and scheduling. Once a code is chosen, an enormous number of low-level choices — which gates run when, on which qubits, in what order — determine how well the abstract error-correcting power is actually realized on noisy hardware. These choices were long made by hand and mostly for the surface code, but as the field moves toward more qubit-efficient codes with intricate structure, hand-tuning does not scale, and automated tools that understand both the code and the decoder become essential. This mirrors the history of classical computing, where compilers took over decisions once made by expert assembly programmers. The broader effort to squeeze more reliability out of the same physical hardware by being cleverer about error correction is the same undertaking the work on better-than-worst-case decoding for quantum error correction covered elsewhere on this site pursues, extracting reliability the raw device does not give for free. AlphaSyndrome contributes on the scheduling side, showing that automatically shaping error propagation with a decoder-aware search can match human experts on the surface code and surpass them on newer codes.

If you remember only three things

1. Quantum error correction runs syndrome-measurement cycles over and over — measuring commuting parity checks called stabilizers to detect errors without disturbing the data — and these cycles dominate a fault-tolerant machine's cost. Because the stabilizers commute, the measurements can be ordered many valid ways, but the order is not free: a single fault on an ancilla qubit spreads to different data qubits depending on the gate order (a hook error), so different schedules give very different logical error rates.
2. Prior practice optimized schedules for circuit depth, which ignores where faults propagate, and good reliability-aware schedules were hand-crafted only for the surface code. AlphaSyndrome instead frames scheduling as shaping error propagation to keep faults away from logical operators and within the decoder's correctable region, and searches the huge space of orderings with Monte Carlo Tree Search, scoring each candidate by noisy simulation with the actual decoder in the loop.
3. Across diverse code families, sizes, and decoders, AlphaSyndrome reduces logical error rates by 80.6 percent on average (up to 96.2 percent) versus depth-optimal schedules, automatically matches Google's hand-crafted surface-code schedules, and outperforms IBM's schedule for the Bivariate Bicycle code. It may accept slightly more depth for far fewer errors, the search is a substantial offline computation, and its results are tied to the decoder and noise model it optimizes against.

Check yourself

Check your understanding

1. Why does the order of stabilizer measurements affect the logical error rate, even though stabilizers commute?
2. What was wrong with the previous approaches to syndrome-measurement scheduling?
3. How does AlphaSyndrome find a good schedule?
4. Predict: AlphaSyndrome is run on the surface code (which Google already hand-tuned) and on the newer Bivariate Bicycle code (hand-tuned by IBM). What should you expect, and why?

Sources

The paper is “AlphaSyndrome: Tackling the Syndrome Measurement Circuit Scheduling Problem for QEC Codes” by Yuhao Liu, Shuohao Ping, Junyu Zhou, Ethan Decker, Justin Kalloor, Mathias Weiden, Kean Chen, Yunong Shi, Ali Javadi-Abhari, Costin Iancu, and Gushu Li (University of Pennsylvania, IBM Research, Lawrence Berkeley National Laboratory, and University of Michigan), published at ASPLOS 2026, DOI 10.1145/3779212.3790123. It is licensed CC BY.

This explainer is written from the paper’s full text (arXiv:2601.12509). Quantum error correction (QEC) repeatedly executes syndrome-measurement cycles that dominate the spacetime and hardware cost of a fault-tolerant machine. Although stabilizers commute and admit many valid execution orders, different schedules induce distinct error-propagation paths under realistic noise (via hook errors), leading to large variations in logical error rate, and effective scheduling outside surface codes was largely unexplored. AlphaSyndrome is an automated synthesis framework for scheduling syndrome-measurement circuits in general commuting-stabilizer codes under minimal assumptions (mutually commuting stabilizers and a heuristic decoder). It formulates scheduling as an optimization problem that shapes error propagation to (i) avoid patterns close to logical operators and (ii) remain within the decoder’s correctable region, and it uses Monte Carlo Tree Search (MCTS) to explore ordering and parallelism, guided by code structure and by decoder feedback obtained from noisy simulation rollouts with the decoder in the loop. Across diverse code families, sizes, and decoders, AlphaSyndrome reduces logical error rates by 80.6 percent on average (up to 96.2 percent) relative to depth-optimal baselines, matches Google’s hand-crafted surface-code schedules, and outperforms IBM’s schedule for the Bivariate Bicycle code. No numbers beyond the paper’s own have been introduced; exact search parameters, noise models, decoders, and full results should be confirmed in the paper.