Fault-Tolerant Measurement Schedules

• Fault-Tolerant Measurement Schedules are protocols that define the order and grouping of quantum measurements to ensure low-weight faults are distinguishable and correctable.
• They integrate layerwise consumption, compressed syndrome extraction, and adaptive allocation to optimize circuit depth and measurement overhead under diverse noise models.
• Recent advances extend these schedules into geometric and hardware-adaptive strategies, balancing error suppression with resource efficiency for scalable quantum error correction.

Fault-tolerant measurement schedules are measurement protocols in which the ordering, grouping, and repetition of measurements are chosen so that low-weight faults remain distinguishable and correctable, while measurement overhead, circuit depth, and fault propagation remain controlled. In the recent literature, the term is used at several levels of abstraction: as the layerwise consumption rule for foliated three-dimensional cluster states in measurement-based quantum computing (MBQC), as the round structure for syndrome extraction in stabilizer-code quantum error correction, as a compressed sequence of stabilizer products that preserves code distance, and as an adaptive allocation policy for noisy logical readout. Across these settings, the central criterion is not merely whether the intended observables are measured, but whether the resulting detector or syndrome structure supports fault-tolerant decoding under the relevant noise model (Derks et al., 2024, Anker et al., 8 Sep 2025, Mahmoud et al., 27 Mar 2026).

1. Formal definitions and fault-tolerance criteria

For an $[n,k,d]$ code, a measurement schedule can be specified as a sequence of $n_M$ rounds in which a disjoint set of Pauli operators is measured in each round. In the detector-error-model formulation, such a schedule is fault-tolerant to distance $d=2t+1$ if, for every syndrome $\mathbf{s}$, there exists a correction $c(\mathbf{s})$ such that every syndrome-consistent error of weight at most $t$ is mapped to a residual output error no worse than the internal damage caused by the circuit. This formulation makes the schedule itself part of the error-correcting procedure rather than a neutral implementation detail (Derks et al., 2024).

A complementary definition appears in compressed syndrome extraction. There, a measurement schedule is a sequence of stabilizer measurements that enables fault-tolerant error correction even when the measured operators are fewer than the full set of independent generators. The paper introducing this framework defines weak fault tolerance for distance $d=2t+1$ by the condition that, when the input has $r$ errors and the error-correction procedure suffers $s$ further errors, the corrected output has at most $s$ errors whenever $n_M$0. Under local noise with probability $n_M$1 on each data qubit before each stabilizer measurement and probability $n_M$2 on each syndrome qubit before measurement, the logical error probability scales like $n_M$3 (Anker et al., 8 Sep 2025).

In fault-tolerant cluster states (FTCSs), the schedule is encoded geometrically. A 3D cluster state simultaneously represents the MBQC resource state and the repeated syndrome-measurement structure for fault tolerance. In the bulk of the FTCS, all qubits are measured in the $n_M$4 basis; the syndrome graph is reconstructed from parity constraints on those measurement outcomes, and odd-parity vertices are interpreted as defects or error endpoints. This viewpoint makes explicit that fault tolerance is embedded in the measurement record itself (Nickerson et al., 2018).

A common misconception is that fault-tolerant scheduling is equivalent to “measuring all checks often enough.” The cited work instead treats schedule design as a distinguishability problem: dangerous low-weight error patterns must be separated in syndrome space, and the separation depends on geometry, detector choice, circuit ordering, and measurement overhead, not only on the nominal stabilizer set (Derks et al., 2024).

2. Foliated schedules and hyperbolic cluster states

In foliated MBQC, the schedule is inherited from a CSS code that is lifted into a 3D cluster-state resource. Hyperbolic cluster states extend this construction from Euclidean lattices to periodic negatively curved $n_M$5 lattices satisfying

$n_M$6

For finite periodic realizations, the combinatorial relations $n_M$7, $n_M$8, and $n_M$9 imply

$d=2t+1$0

so the finite periodic hyperbolic sheet lies on a surface of genus $d=2t+1$1. In the $d=2t+1$2 example used in the simulations, periodic boundary conditions give a closed surface of genus $d=2t+1$3 (Mahmoud et al., 27 Mar 2026).

On such a surface, the underlying CSS code is a hyperbolic surface-code-type construction with physical qubits on edges, $d=2t+1$4-type plaquette checks on faces, and $d=2t+1$5-type star checks on vertices: $d=2t+1$6 The number of logical qubits is $d=2t+1$7, and the encoding rate

$d=2t+1$8

approaches a nonzero constant as $d=2t+1$9. This constant-rate behavior is one of the main reasons the measurement schedule is significant: the foliated resource can support more logical qubits per physical qubit than Euclidean cluster-state constructions while preserving a finite threshold (Mahmoud et al., 27 Mar 2026).

The foliation procedure prepares data qubits and ancilla check qubits in $\mathbf{s}$0, entangles each check ancilla with the data qubits in its support by $\mathbf{s}$1 gates, and alternates primal and dual layers. For a primal layer, the cluster-state stabilizers are

$\mathbf{s}$2

and, in the full 3D foliated complex,

$\mathbf{s}$3

Measuring a face ancilla $\mathbf{s}$4 in the $\mathbf{s}$5 basis with outcome $\mathbf{s}$6 projects the neighboring data qubits onto an eigenstate of the plaquette operator $\mathbf{s}$7 with eigenvalue $\mathbf{s}$8 (Mahmoud et al., 27 Mar 2026).

The schedule that makes this construction fault-tolerant is layerwise in the foliation direction. The resource is built by stacking $\mathbf{s}$9 layers and then measuring all qubits in the $c(\mathbf{s})$0 basis, with the final layer left unmeasured in the teleported-memory picture. The foliated direction functions as a discrete time coordinate: successive layers are measured, syndrome information is extracted from each layer’s parity outcomes, and the logical state is teleported from the input layer to the output layer up to Pauli byproduct operators determined by the outcomes (Mahmoud et al., 27 Mar 2026).

Within each stabilizer neighborhood, the local gate order is fixed. In the explicit hyperbolic implementation, $c(\mathbf{s})$1 gates are applied around each face in a counterclockwise order. The commutation relation

$c(\mathbf{s})$2

shows that an ancilla $c(\mathbf{s})$3 fault can propagate into a contiguous chain of $c(\mathbf{s})$4 faults on neighboring data qubits. The stated purpose of the ordering is to keep propagated faults predominantly string-like, which matches the assumptions of minimum-weight perfect matching (MWPM) decoding (Mahmoud et al., 27 Mar 2026).

The parity checks themselves occupy local 3D bi-pyramidal neighborhoods whose equators lie in one layer and whose apices lie in adjacent layers. For the $c(\mathbf{s})$5 geometry, $c(\mathbf{s})$6-type checks have triangular equators and $c(\mathbf{s})$7-type checks have octagonal equators. The parity-check outcome is given by the sum mod $c(\mathbf{s})$8 of the single-qubit measurement outcomes on the corresponding nodes. The decoding pipeline first tabulates the syndrome produced by every distinct single fault in the circuit-level depolarizing model, then builds a weighted decoding graph with edge weights

$c(\mathbf{s})$9

runs MWPM separately on primal and dual graphs, converts matched pairs into shortest paths, and declares failure when the residual chain has nontrivial pairing with a logical correlation surface (Mahmoud et al., 27 Mar 2026).

At fixed foliation depth $t$0, using $t$1 Monte Carlo trials per physical error rate, the $t$2 code yields threshold estimates of approximately $t$3 and $t$4, compared with a commonly quoted Euclidean RHG threshold of about $t$5 under comparable circuit-level noise. The largest reported instance has $t$6 data qubits per sheet, $t$7, $t$8, $t$9, $d=2t+1$0, $d=2t+1$1 cluster-state qubits, $d=2t+1$2, and $d=2t+1$3 distinct single-location fault processes. The paper interprets these results as evidence that a geometry-sensitive but operationally simple layerwise schedule can preserve a threshold of the same order as RHG while retaining constant encoding rate (Mahmoud et al., 27 Mar 2026).

3. Beyond foliation and the geometry of fault-tolerant cluster states

The FTCS framework is broader than foliated CSS constructions. In the generalized 3D cell-complex picture, cluster-state stabilizers can be written as

$d=2t+1$4

and multiplying face stabilizers around a cell produces closed stabilizers

$d=2t+1$5

The syndrome graph is the 1-skeleton of the dual cell complex: vertices correspond to syndrome checks, edges to measured qubits, and a measurement error on an edge flips the parity at the two endpoints (Nickerson et al., 2018).

In standard foliated constructions, the geometry is layered and prism-like, with natural input and output layers. The beyond-foliation result is that a 3D FTCS need not arise from any foliation of a 2D stabilizer code. The key structural reason is that, in a generic 3D cell complex, the primal geometry does not uniquely determine the dual geometry. This permits more independent control over $d=2t+1$6- and $d=2t+1$7-part geometries and allows syndrome-graph degree to be reduced below the degree-5 lower bound of foliated surface-code FTCSs (Nickerson et al., 2018).

The principal geometric operation is splitting. A vertex in the syndrome graph is replaced by two new vertices connected by a new edge, with the original incident edges partitioned between them. In the dual complex, this corresponds to cutting a cell into two connected pieces and adding a new bisecting face. Primal and dual splits commute, so the primal and dual syndrome graphs can be tuned independently without ambiguity in the final geometry (Nickerson et al., 2018).

Several explicit FTCS families are obtained in this way.

FTCS	Key structure	Thresholds
Cubic FTCS	cubic syndrome graph	erasure $d=2t+1$8, Pauli $d=2t+1$9
Diamond FTCS	self-dual, degree $r$0, hexagonal faces	erasure $r$1, Pauli $r$2
Doubled-edge cubic FTCS	self-dual, octagonal faces, doubled syndrome edges	erasure $r$3, Pauli $r$4
Triamond FTCS	self-dual, degree $r$5, decagonal faces	erasure $r$6, Pauli $r$7

The diamond FTCS is obtained by matched primal and dual splits of the cubic lattice, yielding a self-dual degree-4 syndrome graph with hexagonal faces and cluster-state qubits of bond degree $r$8. The triamond FTCS uses a 3-split of the cubic lattice, giving a self-dual degree-3 syndrome graph, decagonal faces, and cluster-state qubits with $r$9 bonds. The doubled-edge cubic FTCS inserts a degree-2 vertex into each edge of both primal and dual lattices, producing octagonal faces and an interpretation in which each original cubic-FTCS qubit is encoded into a 2-qubit parity code; if each original edge is doubled, then $s$0 and $s$1, while $s$2-segment divisions give $s$3 with cluster-state valence $s$4 (Nickerson et al., 2018).

The bulk schedule remains structurally simple across these examples: prepare the 3D cluster geometry, measure every bulk qubit in the $s$5 basis, reconstruct stabilizer parities from vertex incidences in the syndrome graph, decode defect pairs, and infer logical correlation operators as membrane-like connected surfaces of $s$6 operators. The significance is that error correction is geometrically embedded in the measurement record itself, rather than added by a separate syndrome-extraction circuit (Nickerson et al., 2018).

A second misconception follows from the foliated literature: that layered constructions are necessary for implementability. The beyond-foliation work states that self-dual FTCSs such as the cubic, diamond, triamond, and doubled-edge cubic constructions can still be prepared and measured layer by layer in a 2D physical architecture, including matter-based and photonic settings (Nickerson et al., 2018).

4. Compressed schedules and detector-error-model synthesis

One line of work reduces schedule length by replacing direct measurement of all $s$7 independent stabilizer generators with measurements of products or linear combinations of generators. If $s$8 is the stabilizer or parity-check matrix and $s$9 is a classical parity-check matrix with $s$0, the measured matrix is

$s$1

Instead of measuring the full syndrome $s$2, one measures the compressed syndrome $s$3. The controlling parameter is the maximum syndrome weight

$s$4

If $s$5 is the parity-check matrix of a classical $s$6 code, then the main theorem states that $s$7 implies either $s$8 or $s$9. Under this condition, compression preserves detectability of all correctable errors (Anker et al., 8 Sep 2025).

This theorem leads directly to schedule-length bounds. BCH codes yield $n_M$00. For LDPC codes in which each qubit participates in at most $n_M$01 checks, $n_M$02, so the number of measurements becomes $n_M$03. For codes obtained by concatenating a smaller code with itself $n_M$04 times, the schedule length becomes $n_M$05. Repeating such a schedule $n_M$06 times gives weak fault tolerance to distance $n_M$07, and the paper further states that Campbell’s construction converts the compressed stabilizer set into a single-shot fault-tolerant measurement scheme with the same asymptotic measurement counts (Anker et al., 8 Sep 2025).

The principal tradeoff is between fewer measurements and higher stabilizer weight. BCH-based compression can substantially reduce the number of measurements, but the resulting measured stabilizers may have large weight, often $n_M$08 in the worst case. The mitigation strategy is to partition stabilizers into subsets with disjoint supports and compress each subset separately. For the surface code, this preserves the asymptotic $n_M$09 scaling while reducing measured-stabilizer weight. In the reported numerics, a distance-$n_M$10 surface code on $n_M$11 qubits has $n_M$12 independent generators; standard repeated extraction uses about $n_M$13 measurements, whereas the compressed schedule uses $n_M$14 measurements (Anker et al., 8 Sep 2025).

Numerical studies under several noise models indicate that the compressed schedules preserve the characteristic exponential suppression of logical error associated with weak fault tolerance. The paper reports an apparent threshold around $n_M$15 under code-capacity noise, threshold-like behavior around $n_M$16 for one round under phenomenological noise, a pseudo-threshold around $n_M$17 for $n_M$18 repeated rounds under phenomenological noise, and a pseudo-threshold around $n_M$19 for $n_M$20 under uncorrelated circuit-like noise (Anker et al., 8 Sep 2025).

A separate but related design methodology treats the schedule as a detector-separation problem. In the detector-error-model formalism,

$n_M$21

where $n_M$22 is a detector matrix encoding noiseless parity constraints among measurement outcomes and $n_M$23 records which elementary circuit errors flip which measurement outcomes. The syndrome seen by the decoder is $n_M$24. A detector choice affects the sparsity and decoder convenience of the Tanner graph, but the circuit distance is independent of the detector matrix (Derks et al., 2024).

The synthesis procedure is explicit: propose a schedule, build $n_M$25, identify low-weight errors that share a detector signature but have different output effects, and add or rearrange measurements until those collisions disappear. For the $n_M$26 color code, the paper exhibits a short schedule measuring five $n_M$27-plaquette stabilizers that is not fault-tolerant because distinct low-weight errors yield the same syndrome while inducing different outputs. The ambiguity can be removed either by repeating the first round at the end or by measuring the product of the two blue plaquettes. For a distance-5 repetition code, measuring the generators twice in four rounds is also insufficient, but a different 4-round schedule becomes fault-tolerant by measuring $n_M$28 and $n_M$29 in round $n_M$30. For the $n_M$31 color code, the reported schedules include a shortest found nonlocal schedule with $n_M$32 measurements in $n_M$33 steps, a local schedule with $n_M$34 measurements in $n_M$35 steps, and a local schedule with fewer high-weight measurements using $n_M$36 measurements in $n_M$37 steps. For the $n_M$38 color code, the paper gives a schedule with $n_M$39 measurements in $n_M$40 steps and maximum measurement weight $n_M$41 (Derks et al., 2024).

Taken together, compressed-syndrome schedules and DEM-guided synthesis show two complementary routes to shorter schedules. The first preserves distance by coding the syndrome itself; the second preserves fault tolerance by enforcing circuit-level distinguishability of detector patterns. Both replace the older assumption that repeating a generating set is the only systematic route to robustness (Anker et al., 8 Sep 2025, Derks et al., 2024).

5. Optimization under measurement overhead and hardware heterogeneity

In early-term fault-tolerant compilation, the schedule-optimization problem is often not combinatorial but frequency-based: how often should syndrome extraction be inserted into a noisy algorithm? In the quantum error detection framework built on $n_M$42 iceberg codes, a schedule is the cadence at which syndrome-extraction subcircuits are inserted into the logical circuit. The experiments sweep values from $n_M$43 to $n_M$44 logical operations between syndrome rounds, and a toy model uses round counts $n_M$45. The core tradeoff is that more frequent syndrome extraction raises the true positive rate for error detection but also raises the false positive rate because the syndrome circuits themselves are noisy and their flagged shots are discarded (Ginsberg et al., 13 Mar 2025).

The statistical model parameterizes this tradeoff by an error probability $n_M$46, a miss-detection probability $n_M$47, and a false-positive rate $n_M$48. It predicts an optimum at intermediate syndrome sensitivity rather than at maximal measurement frequency. The simulations use a circuit-level noise model with single-qubit Pauli errors $n_M$49 each occurring with probability $n_M$50, two-qubit Pauli errors from $n_M$51 each with probability $n_M$52, and SPAM bit-flips with probability $n_M$53. In Grover studies with $n_M$54 iterations and $n_M$55, optimizing the schedule improves algorithm success probabilities by an average of $n_M$56; the reported population average of $n_M$57 is $n_M$58, rising from about $n_M$59 in the lowest noise bin to $n_M$60 in the highest tested bin. At $n_M$61 and $n_M$62, performance peaks at $n_M$63 syndrome rounds before decreasing. The paper therefore treats quantum error detection as a constant-overhead mitigation layer for shallow algorithms rather than a scalable standalone fault-tolerance strategy (Ginsberg et al., 13 Mar 2025).

A different optimization problem arises in logical readout when measurement noise exceeds gate noise. The dynamic measurement scheduling protocol for rotated surface codes treats logical readout as a resource-allocation problem: measurement tasks are redirected from error-prone qubits to more stable nearby nodes using shallow entangled circuits. The protocol defines five modalities,

$n_M$64

and selects among them using topology-aware and error-aware cost functions that combine local measurement error rates, gate error rates, and the number of two-qubit gates in the transfer circuit. The basic parity-transfer primitive is

$n_M$65

and the redirected single-qubit measurement primitive is

$n_M$66

When temporal conflicts and decoherence constraints matter, the scheduling problem is written with time-indexed binary variables $n_M$67 and solved approximately by reinforcement learning (Xu et al., 12 May 2025).

The reported gains are hardware-dependent. Across code distances $n_M$68 to $n_M$69, local measurement scheduling reduces logical error rates; on ibm-ithaca the reduction is up to $n_M$70, while on Sycamore it is about $n_M$71. Fitting

$n_M$72

gives $n_M$73 for ibm-ithaca and $n_M$74 for Sycamore; at $n_M$75, these correspond to roughly $n_M$76 and $n_M$77 physical-qubit reduction, respectively. In the RL setting, convergence occurs within about $n_M$78–$n_M$79 epochs, deeper schedule limits $n_M$80 converge faster, and returns diminish beyond $n_M$81. The stated regime of maximum benefit is measurement-noise-dominated hardware (Xu et al., 12 May 2025).

These results make clear that fault-tolerant measurement schedules are not solely code-theoretic objects. They are also calibration-dependent policies, determined by circuit depth, readout asymmetry, shot budget, and the cost of added syndrome apparatus (Ginsberg et al., 13 Mar 2025, Xu et al., 12 May 2025).

6. Tradeoffs, misconceptions, and current directions

Several recurrent themes organize the subject. First, schedule simplicity does not imply geometric neutrality. In hyperbolic MBQC, the operational rule is simple—measure layer by layer along the foliated direction and use a fixed local ordering of $n_M$82 gates around each face—but the success of that rule depends on the negative-curvature geometry that keeps propagated faults string-like and the encoding rate constant (Mahmoud et al., 27 Mar 2026).

Second, fault-tolerant scheduling is not synonymous with foliation. The beyond-foliation FTCS constructions show that self-dual 3D cluster states with degree-4, degree-3, or mixed-degree syndrome graphs can support fault tolerance even though they are not layered prism stacks of any 2D code. A plausible implication is that measurement scheduling should be viewed as a property of the full cell complex and decoder pair, not only of repeated syndrome extraction inherited from a 2D parent code (Nickerson et al., 2018).

Third, “more measurements” is not a universal prescription. In early-term quantum error detection, increasing syndrome frequency eventually harms performance because the detection circuitry raises false positives and can induce catastrophic post-selection failure (Ginsberg et al., 13 Mar 2025). In compressed syndrome extraction, reducing the number of measurements is possible, but often at the price of higher-weight measured stabilizers (Anker et al., 8 Sep 2025). In DEM-guided schedule synthesis, simply repeating generators is frequently suboptimal; rearranged measurements or selected products can separate dangerous error pairs with fewer rounds (Derks et al., 2024).

Fourth, topology and schedule cannot be fully separated. The beyond-foliation work proves a gate-complementarity bound stating that if a fixed resource state can implement two different gates with erasure thresholds $n_M$83 and $n_M$84, then $n_M$85. The stated interpretation is that erasure thresholds above $n_M$86 require changing the resource-state topology itself, not merely changing the measurement pattern on a fixed cluster state (Nickerson et al., 2018).

Finally, current work points in several distinct but compatible directions. One is geometric enrichment, exemplified by hyperbolic cluster states, whose authors identify explicit fault-tolerant gates—likely via hyperbolic analogues of Dehn twists or lattice surgery—as a next step within the same foliated measurement framework (Mahmoud et al., 27 Mar 2026). Another is algorithmic compression of schedule length via classical coding of syndromes (Anker et al., 8 Sep 2025). A third is circuit-level synthesis and verification using detector error models, where detector sparsity affects decoder convenience without changing circuit distance (Derks et al., 2024). A fourth is hardware-adaptive scheduling for noisy logical readout and early-term error detection, where the optimal schedule depends on local calibration data and resource limits rather than on code distance alone (Xu et al., 12 May 2025, Ginsberg et al., 13 Mar 2025).

Fault-tolerant measurement schedules therefore form a unifying layer between code structure, circuit implementation, and decoder design. Whether encoded into a 3D cluster geometry, compressed into a shorter stabilizer sequence, inferred from a detector error matrix, or adapted online to hardware asymmetry, they determine how measurement records become reliable syndrome information under realistic noise.