Abstract
Practical quantum computing will require error rates well below those achievable with physical qubits. Quantum error correction^{1,2} offers a path to algorithmically relevant error rates by encoding logical qubits within many physical qubits, for which increasing the number of physical qubits enhances protection against physical errors. However, introducing more qubits also increases the number of error sources, so the density of errors must be sufficiently low for logical performance to improve with increasing code size. Here we report the measurement of logical qubit performance scaling across several code sizes, and demonstrate that our system of superconducting qubits has sufficient performance to overcome the additional errors from increasing qubit number. We find that our distance5 surface code logical qubit modestly outperforms an ensemble of distance3 logical qubits on average, in terms of both logical error probability over 25 cycles and logical error per cycle ((2.914 ± 0.016)% compared to (3.028 ± 0.023)%). To investigate damaging, lowprobability error sources, we run a distance25 repetition code and observe a 1.7 × 10^{−6} logical error per cycle floor set by a single highenergy event (1.6 × 10^{−7} excluding this event). We accurately model our experiment, extracting error budgets that highlight the biggest challenges for future systems. These results mark an experimental demonstration in which quantum error correction begins to improve performance with increasing qubit number, illuminating the path to reaching the logical error rates required for computation.
Similar content being viewed by others
Main
Since Feynman’s proposal to compute using quantum mechanics^{3}, many potential applications have emerged, including factoring^{4}, optimization^{5}, machine learning^{6}, quantum simulation^{7} and quantum chemistry^{8}. These applications often require billions of quantum operations^{9,10,11} and stateoftheart quantum processors typically have error rates around 10^{−3} per gate^{12,13,14,15,16,17}, far too high to execute such large circuits. Fortunately, quantum error correction can exponentially suppress the operational error rates in a quantum processor, at the expense of temporal and qubit overhead^{18,19}.
Several works have reported quantum error correction on codes able to correct a single error, including the distance3 Bacon–Shor^{20}, colour^{21}, fivequbit^{22}, heavyhexagon^{23} and surface^{24,25} codes, as well as continuous variable codes^{26,27,28,29}. However, a crucial question remains of whether scaling up the errorcorrecting code size will reduce logical error rates in a real device. In theory, logical errors should be reduced if physical errors are sufficiently sparse in the quantum processor. In practice, demonstrating reduced logical error requires scaling up a device to support a code that can correct at least two errors, without sacrificing stateoftheart performance. In this work we report a 72qubit superconducting device supporting a 49qubit distance5 (d = 5) surface code that narrowly outperforms its average subset 17qubit distance3 surface code, demonstrating a critical step towards scalable quantum error correction.
Surface codes with superconducting qubits
Surface codes^{30,31,32,33,34} are a family of quantum errorcorrecting codes that encode a logical qubit into the joint entangled state of a d × d square of physical qubits, referred to as data qubits. The logical qubit states are defined by a pair of anticommuting logical observables X_{L} and Z_{L}. For the example shown in Fig. 1a, a Z_{L} observable is encoded in the joint Zbasis parity of a line of qubits that traverses the lattice from top to bottom, and likewise an X_{L} observable is encoded in the joint Xbasis parity traversing left to right. This nonlocal encoding of information protects the logical qubit from local physical errors, provided we can detect and correct them.
To detect errors, we periodically measure X and Z parities of adjacent clusters of data qubits with the aid of d^{2} − 1 measure qubits interspersed throughout the lattice. As shown in Fig. 1b, each measure qubit interacts with its neighbouring data qubits to map the joint data qubit parity onto the measure qubit state, which is then measured. Each parity measurement, or stabilizer, commutes with the logical observables of the encoded qubit as well as every other stabilizer. Consequently, we can detect errors when parity measurements change unexpectedly, without disturbing the logical qubit state.
A decoder uses the history of stabilizer measurement outcomes to infer likely configurations of physical errors on the device. We can then determine the overall effect of these inferred errors on the logical qubit, thus preserving the logical state. Most surface code logical gates can be implemented by maintaining logical memory and executing different sequences of measurements on the code boundary^{35,36,37}. Thus, we focus on preserving logical memory, the core technical challenge in operating the surface code.
We implement the surface code on an expanded Sycamore device^{38} with 72 transmon qubits^{39} and 121 tunable couplers^{40,41}. Each qubit is coupled to four nearest neighbours except on the boundaries, with mean qubit coherence times T_{1} = 20 μs and T_{2,CPMG} = 30 μs, in which CPMG represents Carr–Purcell–Meiboom–Gill. As in ref. ^{42}, we implement singlequbit rotations, controlledZ (CZ) gates, reset and measurement, demonstrating similar or improved simultaneous performance as shown in Fig. 1c.
The distance5 surface code logical qubit is encoded on a 49qubit subset of the device, with 25 data qubits and 24 measure qubits. Each measure qubit corresponds to one stabilizer, classified by its basis (X or Z) and the number of data qubits involved (weight, 2 or 4). Ideally, to assess how logical performance scales with code size, we would compare distance5 and distance3 logical qubits under identical noise. Although device inhomogeneity makes this comparison difficult, we can compare the distance5 logical qubit to the average of four distance3 logical qubit subgrids, each containing nine data qubits and eight measure qubits. These distance3 logical qubits cover the four quadrants of the distance5 code with minimal qubit overlap, capturing the average performance of the full distance5 grid.
In a single instance of the experiment, we initialize the logical qubit state, run several cycles of error correction, and then measure the final logical state. We show an example in Fig. 2a. To prepare a Z_{L} eigenstate, we first prepare each data qubit in \(\left0\right\rangle \) or \(\left1\right\rangle \), an eigenstate of the Z stabilizers. The first cycle of stabilizer measurements then projects the data qubits into an entangled state that is also an eigenstate of the X stabilizers. Each cycle contains CZ and Hadamard gates sequenced to extract X and Z stabilizers simultaneously, and ends with the measurement and reset of the measure qubits. In the final cycle, we also measure the data qubits in the Z basis, yielding both parity information and a measurement of the logical state. Preparing and measuring X_{L} eigenstates proceeds analogously. The instance succeeds if the corrected logical measurement agrees with the known initial state; otherwise, a logical error has occurred.
Our stabilizer circuits contain a few modifications to the standard gate sequence described above (see Supplementary Information), including phase corrections to correct for unintended qubit frequency shifts and dynamical decoupling gates during qubit idles^{43}. We also remove certain Hadamard gates to implement the ZXXZ variant of the surface code^{44,45}, which helps symmetrize the X and Zbasis logical error rates. Finally, during initialization, the data qubits are prepared into randomly selected bitstrings. This ensures that we do not preferentially measure even parities in the first few cycles of the code, which could artificially lower logical error rates owing to bias in measurement error (see Supplementary Information).
Error detectors
After initialization, parity measurements should produce the same value in each cycle, up to known flips applied by the circuit. If we compare a parity measurement to the corresponding measurement in the preceding cycle and their values are inconsistent, a detection event has occurred, indicating an error. We refer to these comparisons as detectors.
The detection event probabilities for each detector indicate the distribution of physical errors in space and time while running the surface code. In Fig. 2, we show the detection event probabilities in the distance5 code (Fig. 2b,c) and the distance3 codes (Fig. 2d,e) running for 25 cycles, as measured over 50,000 experimental instances. For the weight4 stabilizers, the average detection probability is 0.185 ± 0.018 (1σ) in the distance5 code and 0.175 ± 0.017 averaged over the distance3 codes. The weight2 stabilizers interact with fewer qubits and hence detect fewer errors. Correspondingly, they yield a lower average detection probability of 0.119 ± 0.012 in the distance5 code and 0.115 ± 0.008 averaged over the distance3 codes. The relative consistency between code distances suggests that growing the lattice does not substantially increase the component error rates during error correction.
The average detection probabilities exhibit a relative rise of 12% for distance5 and 8% for distance3 over 25 cycles, with a typical characteristic risetime of roughly 5 cycles (see Supplementary Information). We attribute this rise to data qubits leaking into noncomputational excited states and anticipate that the inclusion of leakageremoval techniques on data qubits would help to mitigate this rise^{42,46,47,48}. We reason that the greater increase in detection probability in the distance5 code is due to increased stray interactions or leakage from simultaneously operating more gates and measurements.
We test our understanding of the physical noise in our system by comparing the experimental data to a simulation. We begin with a depolarizing noise simulation based on the component error information in Fig. 1c, and then extend to a Pauli simulation with qubitspecific T_{1} and T_{2,CPMG}, transitions to leaked states, and stray interactions between qubits during CZ gates (see Supplementary Information). We refer to this simulation as Pauli+. Figure 2f shows that this second simulator accurately predicts the average detection probabilities, finding 0.180 ± 0.013 for the weight4 stabilizers and 0.116 ± 0.011 for the weight2 stabilizers, with average detection probabilities increasing 7% over 25 cycles (distance5).
Understanding errors through correlations
We next examine pairwise correlations between detection events, which give us finegrained information about which types of error are occurring during error correction. Figure 2a illustrates a few examples of pairwise detections that are generated by X or Z errors in the surface code. Measurement and reset errors are detected by the same stabilizer in two consecutive cycles, which we classify as a timelike pair. Data qubits may experience an X (Z) error while idling during measurement that is detected by its neighbouring Z (X) stabilizers in the same cycle, forming a spacelike pair. Errors during CZ gates may cause a variety of pairwise detections to occur, including spacetimelike pairs that are separated in both space and time. More complex clusters of detection events arise when a Y error occurs, which generates detection events for both X and Z errors.
To estimate the probability for each detection event pair from our data, we compute an appropriately normalized correlation p_{ij} between detection events occurring on any two detectors i and j (refs. ^{42,49}; see Supplementary Information). In Fig. 2h, we show the estimated probabilities for experimental and simulated distance5 data, aggregated and averaged according to the different classes of pairs. In addition to the expected pairs, we also quantify how often detection pairs occur that are unexpected in a local depolarizing circuit model. Overall, the Pauli simulation systematically underpredicts these probabilities compared to experimental data, whereas the Pauli+ simulation is closer and predicts the presence of unexpected pairs, which we surmise are related to leakage and stray interactions. These errors can be especially harmful to the surface code because they can generate multiple detection events distantly separated in space or time, which a decoder might wrongly interpret as multiple independent component errors. We expect that mitigating leakage and stray interactions will become increasingly important as error rates decrease.
Decoding and logical error probabilities
We next examine the logical performance of our surface code qubits. To infer the errorcorrected logical measurement, the decoder requires a probability model for physical error events. This information may be expressed as an error hypergraph: detectors are vertices, physical error mechanisms are hyperedges connecting the detectors they trigger, and each hyperedge is assigned its corresponding error mechanism probability. We use a generalization of p_{ij} to determine these probabilities^{42,50}.
Given the error hypergraph, we implement two different decoders: beliefmatching, an efficient combination of belief propagation and minimumweight perfect matching^{51}; and tensor network decoding, a slow but accurate approximate maximumlikelihood decoder. The beliefmatching decoder first runs belief propagation on the error hypergraph to update hyperedge error probabilities based on nearby detection events^{51,52}. The updated error hypergraph is then decomposed into a pair of disjoint error graphs, one each for X and Z errors^{31}. These graphs are decoded efficiently using minimumweight perfect matching^{53} to select a single probable set of errors.
By contrast, a maximumlikelihood decoder considers all possible sets of errors consistent with the detection events, splits them into two groups on the basis of whether they flip the logical measurement, and chooses the group with the greater total likelihood. The two likelihoods are each expressed as a tensor network contraction^{51,54,55} that exhaustively sums the probabilities of all sets of errors within each group. We can contract the network approximately, and verify that the approximation converges. This yields a decoder that is nearly optimal given the hypergraph error priors, but is considerably slower. Further improvements could come from a more accurate prior, or by incorporating more finegrained measurement information^{47,56}.
Figure 3 shows a comparison of the logical error performance of the distance3 and distance5 codes using the approximate maximumlikelihood decoder. As the ZXXZ variant of the surface code symmetrizes the X and Z bases, differences between the two bases’ logical error per cycle are small and attributable to spatial variations in physical error rates. Thus, for visual clarity, we report logical error probabilities averaged between the X and Z basis; the full dataset may be found in the Supplementary Information. Note that we do not postselect on leakage or highenergy events to capture the effects of realistic nonidealities on logical performance. Over all 25 cycles of error correction, the distance5 code realizes lower logical error probabilities p_{L} than the average of the subset distance3 codes.
We fit the logical fidelity F = 1 − 2p_{L} to an exponential decay. We start the fit at t = 3 to avoid two phenomena that advantage the larger code: the lower detection probability during the first cycle relative to subsequent cycles (Fig. 2b,d), and the higher effective threshold caused by the confinement of errors to thin time slices in fewcycle experiments^{31}. We obtain a logical error per cycle ε_{5} = (2.914 ± 0.016)% (1σ statistical and fit uncertainty) for the distance5 code, compared to an average of ε_{3} = (3.028 ± 0.023)% for the subset distance3 codes, a relative error reduction of about 4%. When decoding with the faster beliefmatching decoder, we fit a logical error per cycle of (3.056 ± 0.015)% for the distance5 code, compared to an average of (3.118 ± 0.025)% for the distance3 codes, a relative error reduction of about 2%. We note that the distance5 logical error per cycle is slightly higher than those of two of the distance3 codes individually, and that leakage accumulation may cause distance5 performance to degrade faster than that of distance3 as logical error probability approaches 50%.
In principle, the logical performance of a distance5 code should improve faster than that of a distance3 code as physical error rates decrease^{33}. Over time, we improved our physical error rates, for example by optimizing single and twoqubit gates, measurement and data qubit idling (see Supplementary Information). In Fig. 3c, we show the corresponding performance progression of distance5 and distance3 codes. The larger code improved about twice as fast until finally overtaking the smaller code, validating the benefit of increaseddistance protection in practice.
To understand the contributions of individual components to our logical error performance, we follow ref. ^{42} and simulate the distance5 and distance3 codes while varying the physical error rates of the various circuit components. As the logicalerrorsuppression factor
is approximately inversely proportional to the physical error rate, we can budget how much each physical error mechanism contributes to 1/Λ_{3/5} (as shown in Fig. 4a) to assess scaling. This error budget shows that CZ error and data qubit decoherence during measurement and reset are dominant contributors.
Algorithmically relevant error rates
Even as known error sources are suppressed in future devices, new dominant error mechanisms may arise as lower logical error rates are realized. To test the behaviour of codes with substantially lower error rates, we use the bitflip repetition code, a onedimensional version of the surface code. The bitflip repetition code does not correct for phaseflip errors and is thus unsuitable for quantum algorithms. However, correcting only bitflip errors allows it to achieve much lower logical error probabilities.
Without postselection, we achieve a logical error per cycle of (1.7 ± 0.3) × 10^{−6} using a distance25 repetition code decoded with minimumweight perfect matching (Fig. 4b). We attribute many of these logical errors in the higherdistance codes to a highenergy impact, which can temporarily impart widespread correlated errors to the system^{57}. These events may be identified by spikes in detection event counts^{42}, and such error mechanisms must be mitigated for scalable quantum error correction to succeed. In this case, there was one such event; after removing it (0.15% of trials), we observe a logical error per cycle of (1.6 ± 0.8) × 10^{−7} (see Supplementary Information). The repetition code results demonstrate that low logical error rates are possible in a superconducting system, but finding and mitigating highly correlated errors such as cosmic ray impacts will be an important area of research moving forwards.
Towards largescale quantum error correction
To understand how our surface code results project forwards to future devices, we simulate the logical error performance of surface codes ranging from distance3 to 25, while also scaling the physical error rates shown in Fig. 1c. For efficiency, the simulation considers only Pauli errors. Figure 4c,d illustrates the contours of this parameter space, which has three distinct regions. When the physical error rate is high (for example, the initial runs of our surface code in Fig. 3c), logical error probability increases with increasing system size (ε_{d+2} > ε_{d}). On the other hand, low physical error rates show the desired exponential suppression of logical error (ε_{d+2} < ε_{d}). This threshold behaviour can be subtle^{58}, and there exists a crossover regime in which, owing to finitesize effects, increasing system size initially suppresses the logical error per cycle before later increasing it. We believe our experiment lies in this regime.
Although our device is close to threshold, reaching algorithmically relevant logical error rates with manageable resources will require an errorsuppression factor Λ_{d/(d+2)} ≫ 1. On the basis of the error budget and simulations in Fig. 4, we estimate that component performance must improve by at least 20% to move below threshold, and substantially improve beyond that to achieve practical scaling. However, these projections rely on simplified models and must be validated experimentally, testing larger code sizes with longer durations to eventually realize the desired logical performance. This work demonstrates the first step in that process, suppressing logical errors by scaling a quantum errorcorrecting code—the foundation of a faulttolerant quantum computer.
Data availability
The data that support the findings of this study are available at https://doi.org/10.5281/zenodo.6804040.
References
Shor, P. W. Scheme for reducing decoherence in quantum computer memory. Phys. Rev. A 52, R2493 (1995).
Gottesman, D. Stabilizer Codes and Quantum Error Correction. PhD thesis, California Institute of Technology (1997).
Feynman, R. P. Simulating physics with computers. Int. J. Theor. Phys. 21, 467–488 (1982).
Shor, P. W. Polynomialtime algorithms for prime factorization and discrete logarithms on a quantum computer. SIAM Rev. 41, 303–332 (1999).
Farhi, E. et al. A quantum adiabatic evolution algorithm applied to random instances of an NPcomplete problem. Science 292, 472–475 (2001).
Biamonte, J. et al. Quantum machine learning. Nature 549, 195–202 (2017).
Lloyd, S. Universal quantum simulators. Science 273, 1073–1078 (1996).
AspuruGuzik, A., Dutoi, A. D., Love, P. J. & HeadGordon, M. Simulated quantum computation of molecular energies. Science 309, 1704–1707 (2005).
Reiher, M., Wiebe, N., Svore, K. M., Wecker, D. & Troyer, M. Elucidating reaction mechanisms on quantum computers. Proc. Natl Acad. Sci. USA 114, 7555–7560 (2017).
Gidney, C. & Ekera, M. How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits. Quantum 5, 433 (2021).
Kivlichan, I. D. et al. Improved faulttolerant quantum simulation of condensedphase correlated electrons via trotterization. Quantum 4, 296 (2020).
Ballance, C., Harty, T., Linke, N., Sepiol, M. & Lucas, D. Highfidelity quantum logic gates using trappedion hyperfine qubits. Phys. Rev. Lett. 117, 060504 (2016).
Huang, W. et al. Fidelity benchmarks for twoqubit gates in silicon. Nature 569, 532–536 (2019).
Rol, M. et al. Fast, highfidelity conditionalphase gate exploiting leakage interference in weakly anharmonic superconducting qubits. Phys. Rev. Lett. 123, 120502 (2019).
Jurcevic, P. et al. Demonstration of quantum volume 64 on a superconducting quantum computing system. Quantum Sci. Technol. 6, 025020 (2021).
Foxen, B. et al. Demonstrating a continuous set of twoqubit gates for nearterm quantum algorithms. Phys. Rev. Lett. 125, 120504 (2020).
Wu, Y. et al. Strong quantum computational advantage using a superconducting quantum processor. Phys. Rev. Lett. 127, 180501 (2021).
Knill, E., Laflamme, R. & Zurek, W. H. Resilient quantum computation. Science 279, 342–345 (1998).
Aharonov, D. & BenOr, M. Faulttolerant quantum computation with constant error rate. SIAM J. Comput. 38, 1207–1282 (2008).
Egan, L. et al. Faulttolerant control of an errorcorrected qubit. Nature 598, 281–286 (2021).
RyanAnderson, C. et al. Realization of realtime faulttolerant quantum error correction. Phys. Rev. X 11, 041058 (2021).
Abobeih, M. et al. Faulttolerant operation of a logical qubit in a diamond quantum processor. Nature 606, 884–889 (2022).
Sundaresan, N. et al. Matching and maximum likelihood decoding of a multiround subsystem quantum error correction experiment. Preprint at https://arXiv.org/abs/2203.07205 (2022).
Krinner, S. et al. Realizing repeated quantum error correction in a distancethree surface code. Nature 605, 669–674 (2022).
Zhao, Y. et al. Realization of an errorcorrecting surface code with superconducting qubits. Phys. Rev. Lett. 129, 030501 (2022).
Ofek, N. et al. Extending the lifetime of a quantum bit with error correction in superconducting circuits. Nature 536, 441–445 (2016).
Flühmann, C. et al. Encoding a qubit in a trappedion mechanical oscillator. Nature 566, 513–517 (2019).
CampagneIbarcq, P. et al. Quantum error correction of a qubit encoded in grid states of an oscillator. Nature 584, 368–372 (2020).
Grimm, A. et al. Stabilization and operation of a Kerrcat qubit. Nature 584, 205–209 (2020).
Kitaev, A. Y. Faulttolerant quantum computation by anyons. Ann. Phys. 303, 2–30 (2003).
Dennis, E., Kitaev, A., Landahl, A. & Preskill, J. Topological quantum memory. J. Math. Phys. 43, 4452–4505 (2002).
Raussendorf, R. & Harrington, J. Faulttolerant quantum computation with high threshold in two dimensions. Phys. Rev. Lett. 98, 190504 (2007).
Fowler, A. G., Mariantoni, M., Martinis, J. M. & Cleland, A. N. Surface codes: towards practical largescale quantum computation. Phys. Rev. A 86, 032324 (2012).
Satzinger, K. et al. Realizing topologically ordered states on a quantum processor. Science 374, 1237–1241 (2021).
Horsman, C., Fowler, A. G., Devitt, S. & Meter, R. V. Surface code quantum computing by lattice surgery. New J. Phys. 14, 123011 (2012).
Fowler, A. G. & Gidney, C. Low overhead quantum computation using lattice surgery. Preprint at https://arXiv.org/abs/1808.06709 (2018).
Litinski, D. A game of surface codes: largescale quantum computing with lattice surgery. Quantum 3, 128 (2019).
Arute, F. et al. Quantum supremacy using a programmable superconducting processor. Nature 574, 505–510 (2019).
Koch, J. et al. Chargeinsensitive qubit design derived from the Cooper pair box. Phys. Rev. A 76, 042319 (2007).
Neill, C. A Path towards Quantum Supremacy with Superconducting Qubits. PhD thesis, Univ. California Santa Barbara (2017).
Yan, F. et al. Tunable coupling scheme for implementing highfidelity twoqubit gates. Phys. Rev. Appl. 10, 054062 (2018).
Chen, Z. et al. Exponential suppression of bit or phase errors with cyclic error correction. Nature 595, 383–387 (2021).
Kelly, J. et al. Scalable in situ qubit calibration during repetitive error detection. Phys. Rev. A 94, 032321 (2016).
Wen, X.G. Quantum orders in an exact soluble model. Phys. Rev. Lett. 90, 016803 (2003).
Bonilla Ataides, J. P., Tuckett, D. K., Bartlett, S. D., Flammia, S. T. & Brown, B. J. The XZZX surface code. Nat. Commun. 12, 2172 (2021).
Aliferis, P. & Terhal, B. M. Faulttolerant quantum computation for local leakage faults. Quantum Inf. Comput. 7, 139–156 (2007).
Suchara, M., Cross, A. W. & Gambetta, J. M. Leakage suppression in the toric code. Proc. 2015 IEEE International Symposium on Information Theory (ISIT) 1119–1123 (2015).
McEwen, M. et al. Removing leakageinduced correlated errors in superconducting quantum error correction. Nat. Commun. 12, 1761 (2021).
Spitz, S. T., Tarasinski, B., Beenakker, C. W. & O’Brien, T. E. Adaptive weight estimator for quantum error correction in a timedependent environment. Adv. Quantum Technol. 1, 1800012 (2018).
Chen, E. H. et al. Calibrated decoders for experimental quantum error correction. Phys. Rev. Lett. 128, 110504 (2022).
Higgott, O., Bohdanowicz, T. C., Kubica, A., Flammia, S. T. & Campbell, E. T. Fragile boundaries of tailored surface codes and improved decoding of circuitlevel noise. Preprint at https://arXiv.org/abs/2203.04948 (2022).
Criger, B. & Ashraf, I. Multipath summation for decoding 2D topological codes. Quantum 2, 102 (2018).
Fowler, A. G., Whiteside, A. C. & Hollenberg, L. C. Towards practical classical processing for the surface code. Phys. Rev. Lett. 108, 180501 (2012).
Bravyi, S., Suchara, M. & Vargo, A. Efficient algorithms for maximum likelihood decoding in the surface code. Phys. Rev. A 90, 032326 (2014).
Chubb, C. T. & Flammia, S. T. Statistical mechanical models for quantum codes with correlated noise. Ann. Inst. Henri Poincaré D 8, 269–321 (2021).
Pattison, C. A., Beverland, M. E., da Silva, M. P. & Delfosse, N. Improved quantum error correction using soft information. Preprint at https://arXiv.org/abs/2107.13589 (2021).
McEwen, M. et al. Resolving catastrophic error bursts from cosmic rays in large arrays of superconducting qubits. Nat. Phys. 18, 107–111 (2022).
Stephens, A. M. Faulttolerant thresholds for quantum error correction with the surface code. Phys. Rev. A 89, 022321 (2014).
Emerson, J., Alicki, R. & Życzkowski, K. Scalable noise estimation with random unitary operators. J. Opt. B 7, S347 (2005).
Acknowledgements
We are grateful to S. Brin, S. Pichai, R. Porat, J. Dean, E. Collins and J. Yagnik for their executive sponsorship of the Google Quantum AI team, and for their continued engagement and support. A portion of this work was performed in the University of California, Santa Barbara Nanofabrication Facility, an open access laboratory. J.M. acknowledges support from the National Aeronautics and Space Administration (NASA) Ames Research Center (NASAGoogle SAA 403512), NASA Advanced Supercomputing Division for access to NASA highperformance computing systems, and NASA Academic Mission Services (NNA16BD14C). D.B. is a CIFAR Associate Fellow in the Quantum Information Science Program.
Author information
Authors and Affiliations
Consortia
Contributions
The Google Quantum AI team conceived and designed the experiment. The theory and experimental teams at Google Quantum AI developed the data analysis, modelling and metrological tools that enabled the experiment, built the system, performed the calibrations and collected the data. The modelling was carried out jointly with collaborators outside Google Quantum AI. All authors wrote and revised the manuscript and the Supplementary Information.
Corresponding author
Ethics declarations
Competing interests
The authors declare no competing interests.
Peer review
Peer review information
Nature thanks Barbara Terhal, Boris Varbanov and the other, anonymous, reviewer(s) for their contribution to the peer review of this work. Peer reviewer reports are available.
Additional information
Publisher’s note Springer Nature remains neutral with regard to jurisdictional claims in published maps and institutional affiliations.
Supplementary information
Supplementary Information
This file contains Supplementary Sections 13–21, Figs. 1–34, a full list of members of Google Quantum AI and References.
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
Google Quantum AI. Suppressing quantum errors by scaling a surface code logical qubit. Nature 614, 676–681 (2023). https://doi.org/10.1038/s41586022054341
Received:
Accepted:
Published:
Issue Date:
DOI: https://doi.org/10.1038/s41586022054341
This article is cited by

An elementary review on basic principles and developments of qubits for quantum computing
Nano Convergence (2024)

Quantum control of a cat qubit with bitflip times exceeding ten seconds
Nature (2024)

A series of fastpaced advances in Quantum Error Correction
Nature Reviews Physics (2024)

Mechanically induced correlated errors on superconducting qubits with relaxation times exceeding 0.4 ms
Nature Communications (2024)

Highthreshold and lowoverhead faulttolerant quantum memory
Nature (2024)