1 Introduction↩︎

Noise is a central obstacle to extracting reliable results from present-day quantum processors. Of the relevant error channels, readout errors are among the most damaging. On current superconducting hardware, single-qubit assignment error rates are routinely on the order of one percent and often exceed two-qubit gate error rates. Although trapped-ion platforms typically achieve lower readout error rates, these remain higher than their two-qubit gate error rates. Because every quantum computation terminates in measurement, readout errors act directly on the data ultimately returned to the user. Moreover, their impact grows with the number of measured qubits. As circuit widths increase, uncorrected readout errors therefore become a leading bottleneck for both expectation-value estimation and sampling-based applications.

A large body of work mitigates readout error through classical post-processing of the measured statistics. The standard strategy characterizes the imperfect measurement as a classical stochastic (assignment, or “confusion”) matrix through a calibration procedure, and then inverts this matrix, or solves an associated constrained least-squares or maximum-likelihood problem, to recover corrected outcome probabilities or operator expectation values [1]–[4]. These methods are effective, and scalable variants avoid constructing the full assignment matrix explicitly [5]–[11]. They share, however, a structural limitation that is central to the present work: they operate at the level of aggregate statistics rather than individual measurement records. The reconstructed object is an estimate of the full outcome distribution or of an expectation value; it is not a corrected set of shots. Moreover, the inverted distribution is in general only a quasi-distribution as it may contain negative entries, so it is not directly samplable without regularization, and reconstructing the full distribution is itself exponentially costly in the number of measured qubits. As a result, these techniques can return accurate expectation values, but they do not yield a stream of individual measurement outcomes distributed according to the ideal, noiseless measurement distribution. For any task that consumes individual samples rather than expectation values (such as sampling subroutines, distribution learning, or any procedure that post-selects on measured bitstrings) distribution-level mitigation is insufficient.

A complementary class of methods instead corrects readout error at the level of individual shots. Immediately before measurement, each data qubit is redundantly encoded by entangling it with one or more freshly prepared ancilla qubits through CNOT gates, mapping \(\alpha_0\ket{0} + \alpha_1\ket{1} \mapsto \alpha_0\ket{0}^{\otimes n} + \alpha_1\ket{1}^{\otimes n}\) after which all qubits are measured in the computational basis. Because the encoding is applied only immediately before readout, it leaves the preceding computation untouched and targets precisely the computational-basis bit-flip errors that dominate measurement noise. Two strategies then follow. In readout error detection, one post-selects on the data and ancilla outcomes agreeing (a unanimous vote) and discards any record in which they disagree, since such a disagreement signals that a readout error has occurred. In readout error correction, one retains every record and assigns the logical outcome by majority vote over the root (data) qubit and its ancillas. Both strategies act shot by shot and therefore return individually corrected measurement records, and hence approximately correct samples, at the cost of a reduced number of retained shots or of residual mis-corrections, respectively. This repetition-code approach to readout, in both its detection and correction forms, has been introduced and analyzed in prior works [12]–[17]. However, these studies have been either entirely theoretical or confined to individual superconducting devices, leaving open how the scheme performs across qualitatively different hardware. In particular, it remains unexplored how the method performs on trapped-ion processors, whose error characteristics differ substantially from those of superconducting platforms, or how its benefit evolves across successive hardware generations.

In this work, we address these questions by by evaluating repetition-code readout error detection and correction on IBM Heron r1, r2, and r3 devices and Quantinuum H1 and H2 trapped-ion quantum processor units. After briefly recalling the basics of these methods in Sec. 2, we present our analysis on their experimental implementation in Sec. 3. We summarize our main conclusions in Sec. 4.

2 Readout error detection and correction with repetition codes↩︎

2.1 Repetition code and decoding rules↩︎

The binary repetition code is the simplest classical linear code. It encodes a single logical bit into \(n\) physical bits by repetition, \[0 \longmapsto \underbrace{00\cdots 0}_{n}, \qquad 1 \longmapsto \underbrace{11\cdots 1}_{n}, \label{eq:codewords}\tag{1}\] so that the codebook consists of the two constant strings, \(\mathcal{C}=\{0^{n},1^{n}\}\). Regarded as a linear code over \(\mathrm{GF}(2)\), the \(n\)-fold repetition code is, in the standard \([n,k,d]\) notation for a code of length \(n\), dimension \(k\), and minimum Hamming distance \(d\), the \([n,1,n]\) code, i.e., it has length \(n\), encodes \(k=1\) logical bit (two codewords), and has minimum distance \(d=n\), since the two codewords differ in every position. It is in fact the unique binary linear code with these parameters, as any \([n,1]\) linear code is generated by a single nonzero codeword whose weight equals the minimum distance. Thus, we adopt the usual shorthand \([n,1]\) for the \(n\)-repetition code.

A code of minimum distance \(d\) can detect up to \(d-1\) errors, or correct up to \(\lfloor (d-1)/2 \rfloor\) errors. For the \([n,1]\) code these bounds correspond to \(n-1\) detectable and \(\lfloor (n-1)/2 \rfloor\) correctable bit flips. We realize the two operating modes through two distinct decoding rules applied to a received \(n\)-bit word \(\mathbf{b}=(b_{1},\dots,b_{n})\).

Unanimous-vote decoding. The word is accepted as error-free only if all of its bits agree, i.e., if \(\mathbf{b}\in\{0^{n},1^{n}\}\); any disagreement flags a detected error. This rule attains the full detection distance: it flags every error pattern of weight between \(1\) and \(n-1\), failing only in the extreme case in which all \(n\) bits are flipped and the received word coincides with the opposite codeword. A flagged word carries no reliable logical value, so the natural response is to discard it. For a memoryless bit-flip channel with crossover probability \(p\) acting independently on each position, an accepted word is mis-assigned only if every bit is flipped onto the opposite codeword, so the residual error among accepted words scales as follows for small \(p\) \[\underset{}{\Pr}\left[\text{error}\mid\text{accept}\right] = \frac{p^n}{(1-p)^n + p^n} \;\sim\; \left(\frac{p}{1-p}\right)^n \sim p^n,\] i.e., decreases exponentially with \(n\). The price is that a growing fraction of words is rejected.

Majority-vote decoding. The logical bit is assigned the value held by the majority of the \(n\) positions. For odd \(n\) this is always well defined and corrects any error of weight up to \((n-1)/2\), whereas for even \(n\) a tie can occur on exactly \(n/2\) flips. We therefore take \(n\) odd whenever the code is used for correction. Unlike unanimous-vote decoding, majority vote returns a logical value for every received word and discards nothing. Under the same independent bit-flip channel, the per-word logical error requires the majority of the bits to flip, i.e., at least \((n+1)/2\) of the \(n\) bits. The logical error is thus given by \[\underset{}{\Pr}\left[\text{error}\right] = \sum_{w=(n+1)/2}^{n} \binom{n}{w}\, p^{w}(1-p)^{n-w},\] which at small \(p\) is dominated by it’s lowest weight-term, \[\binom{n}{(n+1)/2}p^{\,(n+1)/2} \sim p^{\,(n+1)/2},\] a slower suppression than for detection but achieved without rejecting any words.

The two rules thus sit at opposite ends of the detection–correction trade-off intrinsic to any code: unanimous-vote decoding maximizes the number of errors flagged but recovers nothing from a flagged word, while majority-vote decoding always returns a value at the cost of tolerating fewer errors before mis-decoding.

2.2 Application to readout error detection and correction↩︎

The code 1 is classical, and it cannot serve as a general-purpose quantum error-correcting code. Applied to a qubit, the encoding maps \[\alpha_{0}\ket{0}+\alpha_{1}\ket{1} \;\longmapsto\; \alpha_{0}\ket{0}^{\otimes n}+\alpha_{1}\ket{1}^{\otimes n}, \label{eq:encoding}\tag{2}\] which is realized by \(\mathrm{CNOT}\) gates that copy the data qubit’s computational-basis value onto \(n-1\) freshly initialized ancillas. This is not cloning: it copies the value only in the computational basis, producing an entangled (GHZ-type) state rather than \(n\) independent copies, without violating the no-cloning theorem. As a quantum code, 2 is the bit-flip repetition code, which protects only against \(X\)-type errors; a single phase (\(Z\)) error on any qubit is neither detected nor corrected, and protecting an arbitrary qubit against general errors requires a genuine quantum code such as the \([[5,1,3]]\) five-qubit Laflamme code or the \([[9,1,3]]\) Shor code [18]. We therefore do not use 2 for quantum error correction.

Its use here is narrower. We apply the encoding immediately before a computational-basis measurement, and the quantity we wish to protect is not an arbitrary quantum state but the classical computational-basis label that the measurement is meant to return. Readout error is, to a good approximation, a classical bit-flip acting independently on each measured outcome. Under the encoding of Eq. 2 , the single logical value is spread across \(n\) qubits that are then measured independently, yielding \(n\) noisy classical copies of that value, which is precisely the setting of the classical \([n,1]\) repetition code. The decoding rules of Sec. 2.1 apply directly to the \(n\) measured bits: unanimous-vote decoding detects readout errors and post-selects, and majority-vote decoding corrects them. The phase errors the code cannot handle are irrelevant here, since a \(Z\) error immediately before a computational-basis measurement does not change the measured bit. This is why a code inadequate for quantum error correction is nonetheless well matched to readout: the readout channel is essentially a classical bit-flip channel, which is exactly what the repetition code addresses.

The idealized picture of \(n\) independent noisy copies of one bit is exact only in the absence of encoding faults and correlated readout errors. In practice the \(n-1\) encoding \(\mathrm{CNOT}\)s are themselves imperfect, injecting errors before the measurement, and these can be correlated across the encoded qubits. Whether the redundancy supplied by 2 still reduces the readout error once this cost is included is the central empirical question of this work. An additional consideration is the choice of encoding layout: the \(\mathrm{CNOT}\)s can be arranged in different layouts that prepare the same encoded state but differ in their connectivity requirements and in how encoding faults propagate; we defer the description of these layouts to Sec. 3 A, where additional topology constraints are also taken into account.

3 Experimental results↩︎

In this section, we detail the experiments we conducted concerning the detection and correction of readout errors described in 2. The experiments were carried out on IBM’s superconducting devices, spanning the Heron processor family across generations r1 to r3 and on Quantinuum’s trapped-ion H-series (H1-1 and H2-1). We first describe how the repetition-code encodings are implemented on each platform in 3.1. We then evaluate our findings along several axes. We begin by analyzing the error-detection results from unanimous-vote decoding, i.e.post-selecting on the shots in which the data qubit and all of its ancillas agree. In 3.2 we examine how increasing the code distance reshapes the cumulative distribution of post-selected readout errors; in 3.3 we compare the readout error with and without post-selection across successive device generations; and in 3.4 we compare the two encoding topologies, star versus chain, for the [3,1] encoding. Finally, in 3.5 we turn from detection to correction: rather than discarding faulty shots, we recover them by majority-vote decoding, and compare the readout error after correction against the unmitigated baseline.

3.1 Implementing repetition-code encodings on the experimental platforms↩︎

To realize the \([n,1]\) repetition-code encoding of 2 , we use \(n{-}1\) ancilla qubits and \(n{-}1\) \(\operatorname{CNOT}\) gates, arranged in one of two distinct layouts that differ in how the data qubit connects to the ancillas. In the star layout, each \(\operatorname{CNOT}\) is applied from the data qubit to an individual ancilla. In the chain layout, the \(\operatorname{CNOT}\)s are applied sequentially: first from the data qubit to the first ancilla, then from the first ancilla to the second, and so on. The two layouts are shown in 1.

While we implement both layouts across both platforms, device connectivity imposes significant practical constraints. Quantinuum’s trapped-ion processors offer all-to-all connectivity, allowing the star layout to scale without routing overhead. However, on IBM’s heavy-hexagonal lattice, a given qubit is physically connected to a maximum of three neighbors. Consequently, implementing the star layout on these superconducting devices restricts us to at most three ancillas since scaling further requires inserting \(\operatorname{SWAP}\) gates. The chain layout avoids this problem entirely, mapping naturally onto the linear segments of the heavy-hex lattice without routing overhead, making it a highly advantageous topology for devices lacking all-to-all connectivity as shown in 2.

In each experiment, we prepare the data qubits in a computational basis state, either all-zeros, all-ones, or a random bitstring, and read them out. For these inputs, we evaluate the per-qubit (marginal) readout error, computed qubit by qubit, for three cases: without any encoding; with repetition-code encoding decoded by unanimous vote, where shots in which a data qubit and its ancillas disagree are post-selected away (error detection); and with repetition-code encoding decoded by majority vote, where every shot is retained and faulty outcomes are corrected rather than discarded (error correction). Because post-selection discards shots, we additionally investigate the fraction of samples rejected under unanimous-vote decoding when the full bitstring is read out, i.e., when a shot is kept only if every data qubit passes its post-selection simultaneously, which quantifies the sampling overhead of the detection scheme for whole-register readout.

3.2 Effect of code distance on post-selected readout errors↩︎

We first investigate how the code distance affects the readout errors. Consider an idealized situation in which the encoding \(\operatorname{CNOT}\)s are noiseless. In this case, increasing the code distance can only help: a larger \(n\) in the \([n,1]\) repetition code spreads the logical value across more physical qubits, so that under unanimous-vote decoding a larger fraction of readout errors produces a detectable disagreement and is post-selected away. As discussed in 2, for independent readout errors, the residual error among the accepted shots therefore decreases exponentially with \(n\), and one would expect the post-selected readout error to be driven toward zero as the code distance grows.

This conclusion is fragile, however, because the encoding \(\operatorname{CNOT}\)s are not noiseless. Each unit increase in the code distance adds one ancilla qubit and one \(\operatorname{CNOT}\) gate, injecting additional two-qubit-gate error. These extra errors act in the opposite direction: they cause genuine outcomes to be rejected, and more problematically, they can produce correlated faults that are accepted as valid codewords, contributing to the residual error rather than being filtered out. Whether increasing \(n\) actually reduces the post-selected readout error in practice is therefore not clear a priori. It depends on the balance between the readout error, which the redundancy suppresses, and the two-qubit-gate error, which grows with \(n\). This trade-off is precisely what the following experiments probe. To this end, we report the post-selected readout error as a function of code distance on two representative platforms with markedly different error profiles: for the superconducting case we use IBM Pittsburgh, a Heron r3 device, while for the trapped-ion case we use Quantinuum H1-1.

3 reports results for IBM Pittsburgh, a Heron r3 device. Its three panels show the empirical cumulative distribution of the per-qubit readout error across the qubits of the device, for the three input states (all-zeros, all-ones, and a random computational-basis string), comparing the unencoded baseline against the \([2,1]\), \([3,1]\), and \([4,1]\) codes decoded by unanimous vote, all prepared in the star layout. For every input and every code distance, error detection shifts the distribution toward lower error rates relative to the baseline, so that the readout error of a typical qubit is reduced by post-selection. The dependence on code distance, however, varies markedly with the input. For the all-zeros input the distributions show a slight improvement monotonically with distance, in line with the idealized expectation. For the all-ones and random inputs, by contrast, the three code distances perform almost identically: the benefit of error detection is essentially saturated already at \([2,1]\), and adding further ancillas yields no appreciable improvement. The gain from added redundancy appears to be cancelled by the extra gate error, so increasing the code distance brings no further improvement for these inputs on this device.

4 shows the corresponding results for the Quantinuum H1-1 trapped-ion device, for a random computational-basis input. It compares the cumulative distribution of the readout error for the unencoded baseline against those obtained after unanimous-vote decoding of the \([2,1]\) and \([3,1]\) codes, where for the latter we include both the star and the chain layout. Here the ordering is cleaner and matches the idealized picture: the \([2,1]\) code already surpasses the baseline, and the \([3,1]\) code typically reduces the readout error further still, so that on this platform increasing the code distance continues to help rather than saturating. The contrast with the random-input behavior on Pittsburgh is the central observation of this section: the same code distance buys a further improvement on the trapped-ion device but not on the superconducting one. This is consistent with the trade-off set out above: Quantinuum’s substantially lower two-qubit-gate error relative to its readout error keeps the device in the regime where redundancy is still winning, whereas on the superconducting device the gate-error cost of each additional ancilla has already caught up with the benefit. (The two \([3,1]\) layouts are shown here for completeness; we compare star and chain in detail in 3.4.)

3.3 Effectiveness of readout error detection across device generations↩︎

Within a given hardware family, successive generations improve essentially all error parameters at once: newer devices typically exhibit both lower readout error and lower two-qubit-gate error. For the repetition-code scheme these two improvements pull in opposite directions. Lower readout error reduces the very quantity the redundancy is designed to suppress, shrinking the room for error detection to help; lower gate error reduces the cost each added ancilla incurs, making the redundancy cheaper to deploy. The effectiveness of error detection on a newer device therefore depends not on either quantity in isolation but on how the readout error and the gate error move relative to each other from one generation to the next. If readout error falls faster than gate error, the scheme has less to correct and its benefit may erode; if gate error falls faster, the favorable regime widens and the benefit may grow. Which of these occurs is an empirical question about the trajectory of each hardware family.

To probe this, we benchmark error detection across the generations of two platforms, comparing the unencoded baseline against unanimous-vote decoding on each device. For the IBM superconducting family we use the three Heron generations (r1, r2, and r3) with the \([3,1]\) code. For the Quantinuum trapped-ion family we use the H1-1 and H2-1 devices with the \([2,1]\) code. The two platforms are analyzed as separate within-family progressions rather than on a common axis, since they differ both in code distance and in underlying technology; the comparison of interest is how the benefit of error detection evolves along each family’s generational sequence.

5 summarizes the generational comparison. The upper row shows the resulst for the \([3,1]\) code in the star layout across three Heron generations: r1 (Torino), r2 (Kingston), and r3 (Pittsburgh). The lower row uses the \([2,1]\) code across the Quantinuum H1-1 and H2-1 generations.

Two trends are visible simultaneously, and their coexistence is the main point of the figure. First, the baseline curves shift toward lower error with each successive generation: on both platforms the unencoded readout error of a typical qubit improves from the older to the newer device, confirming the expected hardware progression. Second, and despite this moving baseline, error detection continues to deliver a clear improvement on every generation: in each panel the post-selected curve lies below the corresponding baseline, so the scheme produces better readout statistics than the bare measurement even on the most recent devices, where the baseline is already at its best.

3.4 Star versus chain: effect of layout on error detection↩︎

We now isolate the effect of the encoding layout, comparing the star and chain arrangements at fixed code distance \([3,1]\). To stress the scheme, we use the all-ones input throughout this comparison as in the superconducting devices the readout error is larger with such inputs.

6 reports the three Heron generations r1–r3 and 7 the Quantinuum H1-1 device. The two platforms behave differently. On all three Heron generations the star layout outperforms the chain, producing lower post-selected readout error. On the Quantinuum H1-1 device, by contrast, the two layouts perform comparably, with no marked advantage for either. The layout choice thus matters on the superconducting hardware but not on the trapped-ion device.

3.5 From error detection to overhead-free majority-vote correction↩︎

The error-detection scheme examined so far improves readout at a cost: every shot in which the data qubit and its ancillas disagree is discarded, so the gain in accuracy is paid for in retained statistics. Under unanimous-vote decoding this cost compounds across the register, since a shot is kept only if every encoded qubit passes its check simultaneously. As a result, the fraction of shots that survive post-selection falls off exponentially with the number of qubits read out: each additional qubit multiplies the surviving fraction by its own acceptance probability, so even modest per-qubit rejection rates accumulate into a severe overhead for wide registers. For tasks that consume individual samples, this sampling overhead quickly outweighs the benefit of cleaner readout. Majority-vote decoding offers a way out. For the \([n,1]\) repetition code with \(n\) odd, every measured outcome can be assigned a logical value by majority over the \(n\) readout values, so no shot is ever ambiguous and none is discarded. Correction in this sense is overhead-free: it retains the full shot budget while still suppressing readout errors, at the cost of a higher residual error than post-selection, since ambiguous outcomes are corrected rather than removed.

We first quantify this overhead directly. 1 reports the fraction of shots retained under unanimous-vote decoding on IBM Pittsburgh, using \(24\) data qubits, for the \([2,1]\), \([3,1]\), and \([4,1]\) codes. The retained fraction falls sharply with code distance: the \([3,1]\) code keeps only about a third of the shots for both the star and chain layouts, and the \([4,1]\) code keeps roughly \(4\%\). In other words, recovering one clean sample from the \([4,1]\)-encoded register requires on the order of twenty-five raw shots, a substantial penalty that grows with both the code distance and the number of qubits read out. The lower part of 1 reports the corresponding figures for the Quantinuum H1-1 device with 6 data qubits, for the \([2,1]\) and \([3,1]\) cases. Here the picture is far more favorable: over \(90\%\) of the shots are retained. The contrast reflects the two factors: H1-1 has lower readout error per qubit and and we could only use a narrower register, so far fewer shots fail the unanimity check.

We now turn to majority-vote correction, which incurs no shot overhead, and ask whether it still improves on the unencoded readout. We compare the star and chain layouts for the \([3,1]\) code with the qubits initialized to the all-ones computational-basis state, on IBM Pittsburgh and Quantinuum H1-1, against the unencoded baseline. 8 shows, for Pittsburgh, the cumulative fraction of qubits as a function of the estimated per-qubit error probability after majority-vote correction, for both layouts. The two layouts behave qualitatively differently. The star layout improves on the baseline: correcting by majority over the data qubit and its two ancillas yields a lower per-qubit error than the bare measurement. The chain layout, however, performs worse than the baseline—majority-vote correction in this arrangement increases the per-qubit error rather than reducing it.

This is the central caution of the section. Unlike post-selection, which discards faulty shots and can therefore in principle only improve the accepted readout, majority-vote correction keeps every shot and commits to a decoded value; when the encoding is too noisy, that commitment can do net harm. In the chain layout the two \(\operatorname{CNOT}\)s are applied in sequence, so a fault on the first ancilla propagates to the second, producing correlated errors that flip the majority outcome rather than being outvoted. On a device where the encoding gate error is non-negligible, this suffices to push the chain-corrected readout below the baseline, whereas the star layout, with both \(\operatorname{CNOT}\)s controlled by the data qubit, does not chain faults in the same way and remains a net improvement.

9 shows the corresponding results for Quantinuum H1-1. Here both layouts improve on the baseline: the trapped-ion device’s substantially lower two-qubit-gate error means that even the chain arrangement introduces few enough correlated faults that the majority vote remains beneficial. The contrast with Pittsburgh underscores that majority-vote correction is only advantageous when the encoding gate error is small relative to the readout error it is meant to suppress, a condition the trapped-ion device satisfies comfortably for both layouts, but which the superconducting device satisfies only for the star.

4 Conclusion and Outlook↩︎

We have presented a systematic experimental evaluation of repetition-code–based readout error detection and correction across two qubit technologies and several generations of hardware. Specifically, we carried out controlled comparisons of the same scheme on IBM Heron r1–r3 superconducting processors and Quantinuum H1 and H2 trapped-ion processors, varying code distance, device generation, and encoding layout as independent parameters. In addition, we directly measured the overhead incurred by post-selection.

Four observations emerged. First, the benefit of increasing the code distance is strongly device dependent. On the superconducting device the post-selected error saturates already at the \([2,1]\) code for the all-ones and random inputs, the gain from further redundancy being offset by the gate error of the added encoding \(\mathrm{CNOT}\)s, whereas on the trapped-ion device, where the two-qubit-gate error is far smaller relative to the readout error, increasing the distance continues to help. Second, across the generations examined, error detection remained beneficial on every device: although the unencoded baseline improved from one generation to the next on both platforms, post-selection still produced a net reduction in readout error even on the most recent hardware. Third, the encoding layout matters on the superconducting devices, where the star arrangement outperformed the chain on all three Heron generations, but not on the trapped-ion device, where the two layouts performed comparably. Fourth, the two decoding strategies sit at opposite ends of a practical trade-off: unanimous-vote detection lowers the readout error but discards shots at a rate that grows sharply with both code distance and register width, retaining only a few percent of whole-register samples for the \([4,1]\) code on \(24\) qubits, while majority-vote correction discards nothing but, being committed to a decoded value, can do net harm when the encoding is too noisy, as seen for the chain layout on the superconducting device (IBM Pittsburgh), where it pushed the corrected readout below the unencoded baseline.

The implication of these findings is that the scheme is not uniformly advantageous: its configuration (code distance, layout, and the choice between detection and correction) should be matched to the measured error profile of the specific device rather than applied by default.

Several caveats point to future work. Our per-qubit metric does not resolve correlated readout errors, and the mechanism we propose for the chain layout’s failure under correction is inferred rather than measured; both warrant direct characterization, as does whether the benefit of detection erodes as readout error falls over a longer generation sequence of devices. One of the most promising directions opened by this work is the development of adaptive implementations, in which the encoding is tailored to calibration data. In such an approach, encoding would be applied selectively, only to qubits for which it provides a net benefit, while error correction, rather than error detection, would be used only when the associated gate error is sufficiently low to make correction advantageous. Such an adaptive strategy would also help control the post-selection overhead, which remains the principal limitation of detection-based methods for sampling tasks on wide registers. Natural extensions include asymmetry-aware decoding, in which the vote is weighted according to the measured readout-error asymmetries.

References↩︎