Abstract
Quantum computing can become scalable through error correction, but logical error rates only decrease with system size when physical errors are sufficiently uncorrelated. During computation, unused high energy levels of the qubits can become excited, creating leakage states that are longlived and mobile. Particularly for superconducting transmon qubits, this leakage opens a path to errors that are correlated in space and time. Here, we report a reset protocol that returns a qubit to the ground state from all relevant higher level states. We test its performance with the bitflip stabilizer code, a simplified version of the surface code for quantum error correction. We investigate the accumulation and dynamics of leakage during error correction. Using this protocol, we find lower rates of logical errors and an improved scaling and stability of error suppression with increasing qubit number. This demonstration provides a key step on the path towards scalable quantum computing.
Similar content being viewed by others
Introduction
Quantum error correction stabilizes logical states by operating on arrays of physical qubits in superpositions of their computational basis states^{1,2,3}. Superconducting transmon qubits are an appealing platform for the implementation of quantum error correction^{4,5,6,7,8,9,10,11,12,13}. However, the fundamental operations, such as singlequbit gates^{14,15}, entangling gates^{16,17,18,19,20}, and measurement^{21} are known to populate noncomputational levels, creating a demand for a reset protocol^{22,23,24,25,26,27} that can remove leakage population from these higher states without adversely impacting performance in a largescale system. Directly quantifying leakage during normal operation presents another challenge, as optimizing measurement for detecting multiple levels is hard to combine with high speed and fidelity. This calls for analysis methods that use the errors detected during the stabilizer code’s operation to find and visualize undesired correlated errors.
Here we introduce a multilevel reset gate using an adiabatic swap operation between the qubit and the readout resonator combined with a fast return. It requires only 250 ns to produce the ground state with fidelity over 99%, with gate error accurately predicted by an intuitive semiclassical model. This fidelity is achieved simultaneously on all of the first three excited states for a single parameter choice. The gate is straightforward to calibrate and robust to drift due to the adiabaticity. Further, it uses only existing hardware as needed for normal operation and readout, and does not involve strong microwave drives that might induce crosstalk, making it attractive for largescale systems.
We benchmark the reset gate using the bitflip error correction code^{5} and measure growth and removal of leakage insitu. By purposefully injecting leakage, we also quantify the gate’s impact on errors detected in the code. Finally, we introduce a technique for computing the probabilities of error pairs, which allows identifying the distinctive patterns of correlations introduced by leakage. We find applying reset reduces the magnitude of correlations. We use these pair probabilities to inform the identification and correction of errors, improving the code’s performance and stability over time.
Results
Reset gate implementation
The multilevel reset gate consists of the three distinct stages dubbed “swap”, “hold”, and “return” (Fig. 1a). First, we swap all qubit excitations to the resonator by adiabatically sweeping the qubit frequency to ~1 GHz below the resonator frequency. We then hold the qubit below the resonator while excitations decay to the environment. Finally, we return the qubit diabatically to its initial frequency.
Pulse engineering of the “swap” stage is critical to achieving efficient population transfer. We adopt a fast quasiadiabatic approach^{28}, where the qubit frequency changes rapidly when far detuned from the resonator level crossing but changes slowly when near the level crossing. Since the frequency changes more slowly near the level crossing than a linear ramp, the probability of a diabatic error \({{P}_{D}}^{(s)}\) can be upper bounded by a LandauZener transition. This gives \({{P}_{D}}^{(s)}\ll \exp \left({(2\pi g)}^{2}{t}_{{\rm{swap}}}/{{\Delta }}f\right) \sim 1{0}^{3}\), where t_{swap} = 30 ns, Δf = 2.5 GHz is the total qubit frequency change and g ≈ 120 MHz is the qubitresonator coupling^{29}.
The “hold” stage of the protocol is primarily described by resonator photon decay. This decay follows \(\exp (\kappa {t}_{{\rm{hold}}}) \sim 1{0}^{3}\), with t_{hold} ~ 300 ns and κ ~ 1/(45 ns) the resonator decay rate. The qubit’s excitation number remains mostly unchanged during the hold below the resonator as Purcell decay^{30} through the resonator is small. For swap durations below 30 ns the adiabaticity of the swap transition breaks down, and the system enters the “hold” stage in a superposition of the two adiabatic eigenstates. As a result, the probability undergoes coherent Rabi oscillations, which causes an incomplete reset and manifests itself as fringes.
If a single photon remains in the qubitresonator system, the “return” stage of the protocol can be well described by a LandauZener transition. Achieving diabaticity is limited by the finite bandwidth of the control system. We can estimate an effective detuning velocity \({\nu }_{r}=\frac{1}{h}\frac{d}{dt}({E}_{01}{E}_{10})={{\Delta }}f/{t}_{r}\) using the typical ramp timescale t_{r} = 2 ns. The probability of the desired diabatic transition is then \({P}_{D}^{(r)}=\exp [{(2\pi g)}^{2}/{\nu }_{r}]\approx 0.6\). This description can be further extended to the multiphoton case using the LandauZener chain model^{31}.
Combining the semiclassical descriptions of each stage, we can identify two error channels in the reset of a single excitation. The first channel corresponds to the photon adiabatically swapping into the resonator, but then surviving over the hold time and adiabatically transitioning back to the qubit during the return. This is the dominant error channel, with probability \((1{{P}_{D}}^{(s)}){e}^{\kappa {t}_{\text{hold}}}(1{P}_{D}^{(r)}) \sim 5\cdot 1{0}^{4}\). The second channel corresponds to a failed initial swap of the qubit photon, followed by a diabatic transition during the return. The probability of this error is small, approximately \({{P}_{D}}^{(s)}{P}_{D}^{(r)}\ll 1{0}^{4}\). The reset dynamics of the \(\left2\right\rangle\) and \(\left3\right\rangle\) states is similar, with multiple adiabatic transitions moving 2 and 3 photons to the resonator respectively, after which they undergo rapid decay.
We experimentally test our reset gate on a Sycamore processor^{29}, consisting of an array of fluxtunable superconducting transmon qubits^{4,32} with tunable couplers^{17,29,33,34}. Each qubit is coupled to a readout resonator with strength g ≈ 120 MHz, and having a frequency ~1.5 GHz below the qubit. Resonators are coupled to the outside environment through a Purcell filter^{35}.
The reset gate is implemented using fluxtuning pulses to steer the qubit’s frequency to interact with the resonator, see Fig. 2a. The selected qubit has an idle frequency of 6.09 GHz and a nonlinearity of −200 MHz. The qubit starts at its idle frequency, moves past the resonator at 4.67 GHz, and is held 1 GHz below it, followed by a fast return to the idle frequency. We define the reset error as the likelihood of producing any state other than the ground state. The dependence of reset error on swap duration is shown in Fig. 2b for the cases when the qubit is initialized to \(\left1\right\rangle\), \(\left2\right\rangle\), and \(\left3\right\rangle\). We find that the reset error for all of the initialized states decreases until it reaches a readout visibility floor at about 30 ns swap duration. This floor of ~0.2% was also measured independently as the ground state measurement error after heralding; postselecting on a prior measurement of \(\left0\right\rangle\). This indicates that the floor is intrinsic to the measurement, not to the reset gate itself. We notice oscillations in the data which arise from an incomplete swap and are reproduced by the theoretical model results. In Fig. 2c, we keep the swap duration fixed at 30 ns and vary the hold duration. We find that the reset error decreases exponentially until it reaches the readout visibility floor, with a decay that is compatible with 1/κ = 45 ns. We show the landscape of the reset error for the qubit initialized in \(\left1\right\rangle\), experimentally in Fig. 2d, and the model results in Fig. 2e. For a wide choice of parameters above a minimum swap and hold duration, the ground state can be achieved with high fidelity: Experimentally we are limited by readout and theoretically the deviation from the ground state is below 10^{−3}. We also note that the majority of error is favorably in the computational basis, which stabilizer codes can naturally identify and correct. The landscape involving other parameters can be found in Supplementary Note 1.
The data and model results in Fig. 2 show that one can reset a qubit within 250 ns to the ground state with an error of around 10^{−3}. Moreover, the insensitivity to parameter choice, stemming from the adiabaticity of the gate, highlights the protocol’s robustness to drift and noise. This makes it amenable to use in largescale systems. Finally, the demonstrated ability to simultaneously remove occupation from the \(\left1\right\rangle\), \(\left2\right\rangle\), and \(\left3\right\rangle\) states for a single choice of parameters makes this protocol a prime candidate for mitigating leakage in quantum error correction.
Bitflip code
We now benchmark this protocol in the bitflip stabilizer code^{5}, a precursor to the surface code. Here, a fast cycle of Hadamard, entangling, and measurement gates is repeated (Fig. 1b) to extract parity measurements to stabilize the logical state. We note the addition of X gates on the data qubits to depolarize energy relaxation error. Since the reset protocol is designed to unconditionally prepare the ground state, and thus remove all quantum data, we apply it only on the measure qubits immediately after readout. In the absence of reset, we apply no feedback to the measure qubit state but account for this during syndrome decoding as in ref. ^{5}.
We implement a 21 qubit chain on a Sycamore processor (inset of Fig. 3). The qubits chosen had an average T_{1} near 14 μs, with their experimental parameters chosen by optimization^{36}. We start by directly measuring the growth of leakage to \(\left2\right\rangle\) by running the code for a number of rounds and terminating with a measurement that can resolve \(\left2\right\rangle\) on all qubits. Each round is 955 ns long when we include reset. We note that the leakage population is subject to a different readout floor than seen in Fig. 2, as further detailed in Supplementary Note 2. We average over 40 random initial states for the data qubits, and find that the population of \(\left2\right\rangle\) grows and saturates. In the absence of reset, the measure qubits build up a larger \(\left2\right\rangle\) state population than the data qubits.
We fit a simple rate equation model and calculate the leakage (γ_{↑}) and decay (γ_{↓}) rates for the \(\left2\right\rangle\) state population^{15}. Applying reset to the measure qubits breaks the established pattern of growth and requires a different fitting procedure, detailed in Supplementary Note 3. We find a fortyfold increase in γ_{↓} on average for measure qubits with the addition of reset. We also find a 2.4× increase in γ_{↓} on average for data qubits, indicating transport of leakage population from data to measure qubits. We understand this effect as arising naturally in our CZ gate^{33}, which requires a condition that also places \(\left21\right\rangle\) and \(\left03\right\rangle\) on resonance, where the \(\left2\right\rangle\) is on the lower frequency qubit. Where a data qubit is below the measure qubit in frequency, transport of \(\left2\right\rangle\) from the data qubit to \(\left3\right\rangle\) in the measure qubit can occur, where it is subsequently removed by reset.
Injection of leakage
To visualize the pattern of errors that leakage produces, we now inject \(\left2\right\rangle\) into the stabilizer code at specific locations. We insert a complete rotation between \(\left1\right\rangle\) and \(\left2\right\rangle\) on a single qubit immediately after the first Hadamard gates in round 10 of a 30 round experiment. As the data qubits are in either \(\left0\right\rangle\) or \(\left1\right\rangle\), and measure qubits are in an equal superposition of \(\left0\right\rangle\) and \(\left1\right\rangle\) after the Hadamard, the amount of injected \(\left2\right\rangle\) is the same for both measure and data qubits on average. Figure 4 shows the fraction of error detection events, which represents the portion of runs where a given stabilizer measurement reports an unexpected result, indicating an error occurred^{5}. Injected leakage produces two distinct effects; a pair of detection events at injection, and a tail of correlated detection events over the lifetime of the leakage state. As with discrete bitflip errors, the initial pairs of detection events appear sequentially in time for injection on measure qubits, while for data qubits both adjacent measure qubits report error (gray arrows).
The detection event fractions for all qubits are shown in the insets and crosssections are shown in the main figure. We note that the value of the detection event fraction deviates for the first round due to initialization, and for the last round as data qubit measurements are involved^{5}. As can be seen in Fig. 4a, the insertion of leakage in measure qubit 5 (see inset of Fig. 3 for its location) creates two adjacent peaks at a detection event fraction of 0.5, as the injection produces a random readout result in round 10. This is followed by a clear tail of anomalously high levels of detection events that slowly decays over many rounds, indicating errors that are correlated in time. When applying reset, the errors on all measure qubits are more uniform, and the increase in detection events for the first nine rounds becomes flattened. Importantly, the slow decay in errors is no longer visible as the detection event fraction drops to the baseline immediately after the initial pair of detection events. We also insert leakage in the data qubit between measure qubits 4 and 5, see Fig. 4b. We again notice an increase of detection events that slowly decays, now on both neighboring measure qubits. The error decreases more rapidly with reset, corroborating our prior observation that higherlevel states can migrate to measure qubits. In addition, we notice a small increase in detection events around the leakage injection in qubits 3 and 6 in the case of no reset, further indicating that higherlevel states can move between qubits. We notice for both cases a small oddeven oscillation in the data, which we understand as arising from the fact that the injected \(\left1\right\rangle\) to \(\left2\right\rangle\) rotation does not affect the data qubit when it is in state \(\left0\right\rangle\). Since the X gates on data qubits swap \(\left0\right\rangle\) and \(\left1\right\rangle\) in each round, we see a higher likelihood of bit error from energy relaxation in odd rounds after the injection.
The data in Fig. 4 show that the reset protocol can remove large populations of leakage in measure qubits and helps to decrease leakage in data qubits, thereby strongly suppressing timecorrelated tails of detection events. This result also raises the question of how higherlevel state occupations that naturally arise during the stabilizer codes lead to correlated errors.
Leakageinduced correlations
To further quantify this, we analyze the correlations between detection events that arise during normal code operation using the error graph^{5}, see Fig. 5a. We model detection events as arising from independent random processes that flip pairs of measurements^{37}. The probability p_{ij} of the process that flips measurements i and j can be obtained from the observed correlations between detection events,
where x_{i} = 1 if there is a detection event at a given measurement i and x_{i} = 0 otherwise. Here 〈x〉 denotes averaging x over many experimental realizations.
In Fig. 5, we visualize p_{ij} and show autocorrelations for measure qubit 6 and cross correlations between measure qubits 5 and 6. The standard error correction model assumes that detection events occur only in local pairs. For detection events occurring on the same measure qubit, we expect only correlations between adjacent rounds, corresponding to elements adjacent to the main diagonal (p_{i,i±1}) of Fig. 5b, c. For detection events occurring on neighboring measure qubits, we expect only correlations between the qubits in the same round, or adjacent rounds due to the staggered placement of CZ gates. This corresponds to nonzero elements only on and immediately below the main diagonal of Fig. 5d, e. In contrast, without reset, we find that significant unexpected correlations appear (left panels), covering distances of over 10 rounds. With reset, these longrange correlations are mostly removed (right panels). This reveals an underlying checkerboard pattern that arises similarly to the aforementioned oddeven oscillations (see Supplementary Note 5).
Logical performance and Λ_{bit}
Having shown the reset protocol removes leakage and suppresses longdistance correlations, we now look at logical error rates. We run the stabilizer code to a given number of rounds, and feed the detection events into a minimum weight perfect matching algorithm^{38} that identifies and keeps track of errors to return the corrected logical state.
We perform the experiment on 21 qubits, and use subsampling to evaluate performance for smaller subsets of the code (See Supplementary Notes 6 and 7 for details). We use the p_{ij} elements to set the weights for the matching algorithm. We convert the probability of a logical error (P_{L}) at a given number of rounds k to a logical error rate \(\epsilon =[1{(12{P}_{L})}^{(1/k)}]/2\)^{39} for the number of rounds k, shown at 30 rounds in Fig. 6a. Here, the logical error rate is plotted from 5 to 21 qubits, corresponding to an error correction order of n = 1 to 5, meaning at least n + 1 errors must occur to cause a logical error. The error rate of the bitflip code in the absence of correlations should be exponentially suppressed with \(\epsilon \propto 1/{{{\Lambda }}}_{{\rm{bit}}}^{n+1}\).
We find that the logical error rate decreases with number of qubits, with an exponential dependence from 9 qubits up. The data at 5 qubits shows degraded logical performance, which we attribute to relatively narrow code width impacting the performance of syndrome decoding^{40}. As including these points would reduce the quality of the fit and artificially increase the reported value of Λ_{bit}, we exclude them.
We plot Λ_{bit} versus rounds in Fig. 6b. A constant logical error rate should produce a Λ_{bit} that is independent of a round number. In practice, effects including the buildup of leakage, the thermalization of data qubits, and short time boundary effects will produce a higher apparent Λ_{bit} prior to saturation. Without reset, we observe Λ_{bit} decaying over 30 rounds toward a saturation value of 1.98. With the reset, Λ_{bit} stabilizes faster, within 10 rounds, to a higher value of 2.80. Notably, error suppression is enhanced despite the time added to the cycle by reset, where data qubits are exposed to additional decoherence. This highlights the importance of removing the timecorrelated errors induced by leakage, as seen in Fig. 5.
We observe the logical performance stabilizing to values of Λ_{bit} > 1, and that the addition of reset improves both the longtime performance and rate with which the code approaches this value. Moreover, we see deviations from ideal behavior where experiments are small in number of qubits or rounds. This highlights that error suppression is a property that asymptotically emerges with space and time.
In summary, we introduce a reset protocol that uses existing hardware to remove higherlevel states and test it using the bitflip stabilizer code. We show that reset mitigates leakageinduced longtime correlated errors and significantly improves logical error suppression. While optimizing gates and readout to have minimal leakage is a necessary strategy, the correlated nature of the error that leakage induces makes reset protocols critical for practical quantum error correction.
Data availability
The data that support the findings of this study are available from the corresponding author upon reasonable request.
References
Bravyi, S. B. & Kitaev, A. Y. Quantum codes on a lattice with boundary. Preprint at https://arxiv.org/abs/quantph/9811052 (1998).
Fowler, A. G., Mariantoni, M., Martinis, J. M. & Cleland, A. N. Surface codes: towards practical largescale quantum computation. Phys. Rev. A 86, 032324 (2012).
Terhal, B. M. Quantum error correction for quantum memories. Rev. Mod. Phys. 87, 307–346 (2015).
Koch, J. et al. Chargeinsensitive qubit design derived from the cooper pair box. Phys. Rev. A 76, 042319 (2007).
Kelly, J. et al. State preservation by repetitive error detection in a superconducting quantum circuit. Nature 519, 66 (2015).
Chow, J. M. et al. Implementing a strand of a scalable faulttolerant quantum computing fabric. Nat. Commun. 5, 4015 (2014).
Córcoles, A. et al. Detecting arbitrary quantum errors via stabilizer measurements on a sublattice of the surface code. Nat. Commun. 6, 6979 (2015).
Takita, M. et al. Demonstration of weightfour parity measurements in the surface code architecture. Phys. Rev. Lett. 117, 210505 (2016).
Nigg, D. et al. Quantum computations on a topologically encoded qubit. Science 345, 302–305 (2014).
Ristè, D. et al. Detecting bitflip errors in a logical qubit using stabilizer measurements. Nat. Commun. 6, 6983 (2015).
Reed, M. D. et al. Realization of threequbit quantum error correction with superconducting circuits. Nature 482, 382–385 (2012).
Andersen, C. K. et al. Entanglement stabilization using ancillabased parity detection and realtime feedback in superconducting circuits. npj Quantum Inf. https://doi.org/10.1038/s4153401901854 (2019).
Andersen, C. K. et al. Repeated quantum error detection in a surface code. Nat. Phys. 16, 875–880 (2020).
Motzoi, F., Gambetta, J. M., Rebentrost, P. & Wilhelm, F. K. Simple pulses for elimination of leakage in weakly nonlinear qubits. Phys. Rev. Lett. 103, 110501 (2009).
Chen, Z. et al. Measuring and suppressing quantum state leakage in a superconducting qubit. Phys. Rev. Lett. 116, 020501 (2016).
Barends, R. et al. Superconducting quantum circuits at the surface code threshold for fault tolerance. Nature 508, 500 (2014).
Yan, F. et al. Tunable coupling scheme for implementing highfidelity twoqubit gates. Phys. Rev. Appl. 10, 054062 (2018).
Rol, M. A. et al. Fast, highfidelity conditionalphase gate exploiting leakage interference in weakly anharmonic superconducting qubits. Phys. Rev. Lett. 123, 120502 (2019).
Negirneac, V. et al. Highfidelity controlledz gate with maximal intermediate leakage operating at the speed limit in a superconducting quantum processor. Preprint at https://arxiv.org/abs/2008.07411 (2020).
Hazra, S. et al. Engineering cross resonance interaction in multimodal quantum circuits. Appl. Phys. Lett. 116, 152601 (2020).
Sank, D. et al. Measurementinduced state transitions in a superconducting qubit: beyond the rotating wave approximation. Phys. Rev. Lett. https://doi.org/10.1103/PhysRevLett.117.190503 (2016).
Reed, M. D. et al. Fast reset and suppressing spontaneous emission of a superconducting qubit. Appl. Phys. Lett. 96, 203110 (2010).
Geerlings, K. et al. Demonstrating a driven reset protocol for a superconducting qubit. Phys. Rev. Lett. 110, 120501 (2013).
Suchara, M., Cross, A. W. & Gambetta, J. M. Leakage suppression in the toric code. Quantum Inf. Comput. 15, 997–1016 (2015).
Magnard, P. et al. Fast and unconditional allmicrowave reset of a superconducting qubit. Phys. Rev. Lett. 121, 060502 (2018).
Bultink, C. C. et al. Protecting quantum entanglement from leakage and qubit errors via repetitive parity measurements. Sci. Adv. https://doi.org/10.1126/sciadv.aay3050 (2020).
Varbanov, B. M. et al. Leakage detection for a transmonbased surface code. npj Quantum Information https://doi.org/10.1038/s4153402000330w (2020).
Martinis, J. M. & Geller, M. R. Fast adiabatic qubit gates using only σ_{z} control. Phys. Rev. A 90, 022307 (2014).
Arute, F. et al. Quantum supremacy using a programmable superconducting processor. Nature 574, 505–510 (2019).
Sete, E. A., Martinis, J. M. & Korotkov, A. N. Quantum theory of a bandpass purcell filter for qubit readout. Phys. Rev. A 92, 012325 (2015).
Sinitsyn, N. A., Lin, J. & Chernyak, V. Y. Constraints on scattering amplitudes in multistate LandauZener theory. Phys. Rev. A 95, 012140 (2017).
Kjaergaard, M. et al. Superconducting qubits: current state of play. Annu. Rev. Conden. Ma. P. 11, 369–395 (2020).
Foxen, B. et al. Demonstrating a continuous set of twoqubit gates for nearterm quantum algorithms. Phys. Rev. Lett. 125, 120504 (2020).
Neill, C. A path towards quantum supremacy with superconducting qubits. Ph.D. thesis, University of California, Santa Barbara (2017).
Jeffrey, E. et al. Fast accurate state measurement with superconducting qubits. Phys. Rev. Lett. 112, 190504 (2014).
Klimov, P. V., Kelly, J., Martinis, J. M. & Neven, H. The snake optimizer for learning quantum processor control parameters. Preprint at https://arxiv.org/abs/2006.04594 (2020).
Chen, Z. et al. Exponential suppression of bit or phase flip errors with repetitive error correction. Preprint at https://arxiv.org/abs/2102.06132 (2021).
Fowler, A. G., Whiteside, A. C. & Hollenberg, L. C. L. Towards practical classical processing for the surface code: timing analysis. Phys. Rev. A 86, 042313 (2012).
O’Brien, T., Tarasinski, B. & DiCarlo, L. Densitymatrix simulation of small surface codes under current and projected experimental noise. npj Quantum Information 3, 1–8 (2017).
Fowler, A. G. & Martinis, J. M. Quantifying the effects of local manyqubit errors and nonlocal twoqubit errors on the surface code. Phys. Rev. A 89, 032316 (2014).
Author information
Authors and Affiliations
Contributions
M.M., R.B., and A.P. designed the experiment. M.M. and R.B. performed the experiments and analyzed the data. D.K. and A.P. provided theoretical models. Z.C., K.J.S., C.Q., P.V.K., and J.K. provided key components of the experimental setup. J.A. and A.K. analyzed and processed bitflip code data. All authors contributed to the fabrication process, experimental setup, and manuscript preparation.
Corresponding author
Ethics declarations
Competing interests
The authors declare no competing interests.
Additional information
Peer review information Nature Communications thanks Diego Ristè and the other anonymous reviewer(s) for their contribution to the peer review of this work.
Publisher’s note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Supplementary information
Rights and permissions
Open Access This article is licensed under a Creative Commons Attribution 4.0 International License, which permits use, sharing, adaptation, distribution and reproduction in any medium or format, as long as you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made. The images or other third party material in this article are included in the article’s Creative Commons license, unless indicated otherwise in a credit line to the material. If material is not included in the article’s Creative Commons license and your intended use is not permitted by statutory regulation or exceeds the permitted use, you will need to obtain permission directly from the copyright holder. To view a copy of this license, visit http://creativecommons.org/licenses/by/4.0/.
About this article
Cite this article
McEwen, M., Kafri, D., Chen, Z. et al. Removing leakageinduced correlated errors in superconducting quantum error correction. Nat Commun 12, 1761 (2021). https://doi.org/10.1038/s4146702121982y
Received:
Accepted:
Published:
DOI: https://doi.org/10.1038/s4146702121982y
This article is cited by

Demonstrating multiround subsystem quantum error correction using matching and maximum likelihood decoders
Nature Communications (2023)

Erasure conversion in a highfidelity Rydberg quantum simulator
Nature (2023)

Quantum bath suppression in a superconducting circuit by immersion cooling
Nature Communications (2023)

Noisy intermediatescale quantum computers
Frontiers of Physics (2023)

Overcoming leakage in quantum error correction
Nature Physics (2023)
Comments
By submitting a comment you agree to abide by our Terms and Community Guidelines. If you find something abusive or that does not comply with our terms or guidelines please flag it as inappropriate.