Google Quantum AI and Collaborators

(August 24, 2024)

###### Abstract

Quantum error correction[1, 2, 3, 4] provides a path to reach practical quantum computing by combining multiple physical qubits into a logical qubit, where the logical error rate is suppressed exponentially as more qubits are added.However, this exponential suppression only occurs if the physical error rate is below a critical threshold.In this work, we present two surface code memories operating below this threshold: a distance-7 code and a distance-5 code integrated with a real-time decoder.The logical error rate of our larger quantum memory is suppressed by a factor of $\Lambda=2.14\pm 0.02$ when increasing the code distance by two, culminating in a 101-qubit distance-7 code with 0.143% $\pm$ 0.003% error per cycle of error correction.This logical memory is also beyond break-even, exceeding its best physical qubit’s lifetime by a factor of $2.4\pm 0.3$.We maintain below-threshold performance when decoding in real time, achieving an average decoder latency of 63 µs at distance-5 up to a million cycles, with a cycle time of 1.1 µs.To probe the limits of our error-correction performance, we run repetition codes up to distance-29 and find that logical performance is limited by rare correlated error events occurring approximately once every hour, or $3$$\times$$10^{9}$ cycles.Our results present device performance that, if scaled, could realize the operational requirements of large scale fault-tolerant quantum algorithms.

^{†}

^{†}preprint: APS/123-QED

## I Introduction

Quantum computing promises computational speedups in quantum chemistry [5], quantum simulation [6], cryptography [7], and optimization [8].However, quantum information is fragile and quantum operations are error-prone.State-of-the-art many-qubit platforms have only recently demonstrated $99.9\%$ fidelity entangling gates [9, 10], far short of the $<10^{-10}$ error rates needed for many applications [11, 12].Quantum error correction is postulated to realize high-fidelity logical qubits by distributing quantum information over many entangled physical qubits to protect against errors.If the physical operations are below a critical noise threshold, the logical error should be suppressed exponentially as we increase the number of physical qubits per logical qubit.This behavior is expressed in the approximate relation

$\varepsilon_{d}\propto\left(\frac{p}{p_{\text{thr}}}\right)^{(d+1)/2}$ |

for error-corrected surface code logical qubits[4, 3, 13].Here, $d$ is the code distance indicating $2d^{2}-1$ physical qubits used per logical qubit, $p$ and $\varepsilon_{d}$ are the physical and logical error rates respectively, and $p_{\text{thr}}$ is the threshold error rate of the code.Thus, when $p\ll p_{\text{thr}}$, the error rate of the logical qubit is suppressed exponentially in the distance of the code, with the error suppression factor $\Lambda=\varepsilon_{d}/\varepsilon_{d+2}\approx p_{\text{thr}}/p$ representing the reduction in logical error rate when increasing the code distance by two.While many platforms have demonstrated different features of quantum error correction[14, 15, 16, 17, 18, 19, 20], no quantum processor has definitively shown below-threshold performance.

Although achieving below-threshold physical error rates is itself a formidable challenge, fault-tolerant quantum computing also imposes requirements beyond raw performance.These include features like stability over the hours-long timescales of quantum algorithms[21] and the active removal of correlated error sources like leakage[22].Fault-tolerant quantum computing also imposes requirements on classical coprocessors – namely, the syndrome information producedby the quantum device must be decoded as fast as it is generated[23].The fast operation times of superconducting qubits, rangingfrom tens to hundreds of nanoseconds, provide an advantage in speed but also a challenge for decoding errorsboth quickly and accurately.

In this work, we realize surface codes operating below threshold on two superconducting processors.Using a 72-qubit processor, we implement a distance-5 surface code operating with an integrated real-time decoder.In addition, using a 105-qubit processor with similar performance, we realize a distance-7 surface code.These processors demonstrate $\Lambda>2$ up to distance-5 and distance-7, respectively.Our distance-5 quantum memories are beyond break-even, with distance-7 preserving quantum information for more than twice as long as its best constituent physical qubit.To identify possible logical error floors, we also implement high-distance repetition codes on the 72-qubit processor, with error rates that are dominated by correlated error events occurring once an hour.These errors, whose origins are not yet understood, set a current error floor of $10^{-10}$.Finally, we show that we can maintain below-threshold operation on the 72-qubit processor even when decoding in real time, meeting the strict timing requirements imposed by the processor’s fast 1.1 µs cycle duration.

## II A Surface code memory below threshold

We begin with results from our 105-qubit processor depicted in Fig.1a.It features a square grid of superconducting transmon qubits[25] with improved operational fidelities compared to our previously reported processors[26, 17].The qubits have a mean operating $T_{1}$ of 68 µs and $T_{2,\text{CPMG}}$ of 89 µs, which we attribute to improved fabrication techniques, participation ratio engineering, and circuit parameter optimization.Increasing coherence contributes to the fidelity of all of our operations which are displayed in Fig.1b.

We also make several improvements to decoding, employing two types of offline high-accuracy decoders.One is a neural network decoder[27], and the other is a harmonized ensemble[28] of correlated minimum-weight perfect matching decoders[29] augmented with matching synthesis[30].These run on different classical hardware, offering two potential paths towards real-time decoding with higher accuracy.To adapt to device noise, we fine-tune the neural network with processor data[27] and apply a reinforcement learning optimization to the matching graph weights[31].

We operate a distance-7 surface code memory comprising 49 data qubits, 48 measure qubits, and 4 additional leakage removal qubits, following the methods in Ref.[17].Summarizing, we initiate surface code operation by preparing the data qubits in a product state in either the $X_{L}$ or $Z_{L}$ basis of the ZXXZ surface code[32].We then repeat a variable number of cycles of error correction, during which measure qubits extract parity information from the data qubits to be sent to the decoder.Following each syndrome extraction, we run data qubit leakage removal (DQLR)[33] to ensure that leakage to higher states is short-lived.We measure the state of the logical qubit by measuring the individual data qubits and then check whether the decoder’s corrected logical measurement outcome agrees with the initial logical state.

From surface code data, we can characterize the physical error rate of the processor using the bulk error detection probability[34].This is the proportion of weight-4 stabilizer measurement comparisons that detect an error.The surface code detection probabilities are $p_{\text{det}}=(7.7\%,8.5\%,8.7\%)$ for $d=(3,5,7)$.We attribute the increase in detection probability with code size to finite size effects[24] and parasitic couplings between qubits.We expect both effects to saturate at larger processor sizes[35].

We characterize our surface code logical performance by fitting the logical error per cycle $\varepsilon_{d}$ up to 250 cycles, averaged over the $X$ and $Z$ bases.We average the performance of 9 different distance-3 subgrids and 4 different distance-5 subgrids to compare to the distance-7 code.Finally, we compute the error suppression factor $\Lambda$ using linear regression of $\ln(\varepsilon_{d})$ versus $d$.With our neural network decoder, we observe$\Lambda=2.14\pm 0.02$ and $\varepsilon_{7}$ = $(1.43\pm 0.03)\times 10^{-3}$(see Fig.1c-d).With ensembled matching synthesis, we observe$\Lambda=2.04\pm 0.02$ and $\varepsilon_{7}$ = $(1.71\pm 0.03)\times 10^{-3}$.

Furthermore, we simulate logical qubits of higher distances using a noise model based on the measured component error rates in Fig.1b, additionally including leakage and stray interactions between qubits[17, 24].These simulations are shown alongside the experiment in the inset of Fig.1d, both decoded with ensembled matching synthesis.We observe reasonable agreement with experiment and decisive error suppression, affirming that the surface codes are operating below threshold.

Thus far, we have focused on the error suppression factor $\Lambda$, since below threshold performance guarantees that physical qubit lifetimes and operational fidelities can be surpassed with a sufficiently large logical qubit.In fact, our distance-7 logical qubit already has more than double the lifetime of its constituent physical qubits.While comparing physical and logical qubits is subtle owingto their different noise processes, we plot a direct comparison between logical error rate and physical qubit error rate averaged over $X$ and $Z$ basis initializations in Fig.1c.To quantify qubit lifetime itself, we average uniformly over pure states using the metric proposed in Refs.[16, 24].The distance-7 logical qubit lifetime is $291\pm 6$ µs, exceeding the lifetimes of all the constituent physical qubits (median $85\pm 7$ µs, best $119\pm 13$ µs) by a factor of $2.4\pm 0.3$.Our logical memory beyond break-even extends previous results using bosonic codes[36, 37, 16] to multi-qubit codes, and it is a critical step toward logical operation break-even.

## III Logical error sensitivity

Equipped with below-threshold logical qubits, we can now probe the sensitivity of logical error to various error mechanisms in this new regime.We start by testing how logical error scales with physical error and code distance.As shown in Fig.2a, we inject coherent errors with variable strength on both data and measure qubits, and extract two quantities from each injection experiment.First, we use detection probability as a proxy for the total physical error rate.Second, we infer the logical error per cycle by measuring logical error probability at 10 cycles, decoding with correlated matching[29].

In Fig.2b, we plot logical error per cycle versus detection probability for the distance-3, -5, and -7 codes.We find that the three curves cross near a detection probability of 20%, roughly consistent with the crossover regime explored in Ref.[17].The inset further shows that detection probability acts as a good proxy for $1/\Lambda$.When fitting power laws below the crossing, we observe approximately 80% of the ideal value $(d$$+$$1)/2$ predicted by Eq.1.We hypothesize that this deviation is caused by excess correlations in the device.Nevertheless, higher distance codes show faster reduction of logical error, realizing the characteristic threshold behavior *in situ* on a quantum processor.

To quantify the impact of correlated errors along with more typical gate errors, we form an error budget.Following the method outlined in Refs.[17, 38], we estimate the relative contribution of different component errors to $1/\Lambda$.We run simulations based on a detailed model of our 72-qubit processor.The model includes local noise sources due to gates and measurements, as well as two sources of correlated error: leakage, and stray interactions during our CZ gates which can induce correlated $ZZ$ and swap-like errors[24].Fig.2c shows our estimated error budget for $1/\Lambda$ in the 72-qubit processor when decoding with correlated matching.Applying the same decoder to experimental data,the error budget overpredicts $\Lambda$ by 20%, indicating that most but not all error effects in our processor have been captured.Correlated errors make up an estimated 17% of the budget, and while not a dominant contributor, we expect their importance to increase as error rates decrease.Overall, both local and correlated errors from CZ gates are the largest contributors to the error budget.Consequently, continuing to improve both coherence and calibration will be crucial to further reducing logical error.

One potential source of excess correlations that we actively mitigate is leakage to higher excited states of our transmon qubits.During logical qubit operation, we remove leakage from measure qubits using multi-level reset.For data qubits, DQLR swaps leakage excitations to measure qubits (or additional leakage removal qubits)[33].To examine sensitivity to leakage, we measure logical error probability of distance-3 and distance-5 codes in our 72-qubit processor with and without DQLR, with the results shown in Fig.2d.While activating DQLR does not strongly affect distance-3 performance, it substantially boosts distance-5 performance, resulting in a 35% increase in $\Lambda$.Comparatively, the detection probability decreases by only 12%[24], indicating that detection probability is only a good proxy for logical error suppression if errors are uncorrelated.Overall, we find that addressing leakage is crucial to operating surface codes with transmon qubits[39, 15, 33].

Finally, we test sensitivity to drift.Using our 72-qubit processor, we measure logical performance of one distance-5 and four distance-3 codes 16 times over 15 hours, with the results shown in Fig.2e.Prior to the repeated runs, we employ a frequency optimization strategy which forecasts defect frequencies of two-level systems (TLS).This helps to avoid qubits coupling to TLSs during the initial calibration as well as over the duration of the experiments.Additionally, between every four experimental runs, we recalibrate the processor to account for potential qubit frequency and readout signal drift.We observe an average $\Lambda=2.18\pm 0.07$ (standard deviation) and best $\Lambda=2.31\pm 0.02$[24] when decoding with the neural network.While the performance of the worst distance-3 quadrant appears to fluctuate due to a transient TLS moving faster than our forecasts, this fluctuation is suppressed in the distance-5 code, suggesting that larger codes are less sensitive to component-level fluctuations.Additionally, the logical error rates of experiments right after drift recalibration are not appreciably lower than those just prior, indicating that our logical qubit is robust to the levels of qubit frequency and readout drift present.These results show that superconducting processors can remain stable over the hours-long timescales required for large scale fault-tolerant algorithms[21].

## IV Probing the ultra-low error regime with repetition codes

Despite realizing below-threshold surface codes, orders of magnitude remain between present logical error rates and the requirements for practical quantum computation.In previous work running repetition codes, we found that high-energy impact events occurred approximately once every 10 seconds, causing large correlated error bursts which manifested a logical error floor around $10^{-6}$[17].Such errors would block our ability to run error-corrected algorithms in the future, motivating us to reassess repetition codes on our newer devices.

Using our 72-qubit processor, we run a distance-29 repetition code for 1000 cycles of error correction over $2\times 10^{7}$ shots split evenly between bit- and phase-flip codes.In total, we execute $2\times 10^{10}$ cycles of error correction comprising 5.5 hours of processor execution time.Given the logical error probability $p_{L}$ at 1000 cycles, we infer the logical error per cycle as $\varepsilon_{d}=\frac{1}{2}\left(1-(1-2p_{L})^{1/1000}\right)$.To assess how the logical error per cycle scales with distance-$d$, we follow Ref.[38] and subsample lower distance repetition codes from the distance-29 data.

Averaging over bit- and phase-flip repetition codes, we obtain an error suppression factor $\Lambda=8.4\pm 0.1$ when fitting logical error per cycle versus code distance between $d=5$ and 11, as shown in Fig.3a.Notably, the error per cycle is suppressed far below $10^{-6}$, breaking past the error floor observed previously.We attribute the mitigation of high-energy impact failures to gap-engineered Josephson junctions[40].However, at code distances $d\geq 15$, we observe a deviation from exponential error suppression at high distances culminating in an apparent logical error floor of $10^{-10}$.Although we do not observe any errors at distance-29, this is likely due to randomly decoding correctly on the few most damaging error bursts.While this logical error per cycle might permit certain fault-tolerant applications[11], it is still many orders of magnitude higher than expected and precludes larger fault-tolerant circuits[21, 12].

When we examine the detection patterns for these high-distance logical failures, we observe two different failure modes.The first failure mode manifests as one or two detectors suddenly increasing in detection probability by over a factor of 3, settling to their initial detection probability tens or hundreds of cycles later[24].These less damaging failures could be caused by transient TLS’s appearing near the operation frequencies of a qubit, or by coupler excitations, but might be mitigated using methods similar to Refs.[39, 41].The second and more catastrophic failure mode manifests as many detectors experiencing a larger spike in detection probability simultaneously; an example is shown in Fig.3d.Notably, these anisotropic error bursts are spatially localized to neighborhoods of roughly 30 qubits (see inset).Over the course of our $2\times 10^{10}$ cycles of error correction, our processor experienced six of these large error bursts, which are responsible for the highest-distance failures.These bursts, such as the event shown in Fig.3d, are different from previously observed high-energy impact events[17].They occur approximately once an hour, rather than once every few seconds, and they decay with an exponential time constant around 400 µs, rather than tens of milliseconds.We do not yet understand the cause of these events, but mitigating them remains vital to building a fault-tolerant quantum computer.These results reaffirm that long repetition codes are a crucial tool for discovering new error mechanisms in quantum processors at the logical noise floor.

Furthermore, while we have tested the scaling law in Eq.1 at low distances, repetition codes allow us to scan to higher distances and lower logical errors.Following a similar coherent error injection method as in the surface code, we show the scaling of logical error versus physical error and code distance in Fig.3b-c, observing good agreement with $O(p^{(d+1)/2})$ error suppression.For example, reducing detection probability by a factor of 2 manifests in a factor of 250 reduction in logical error at distance-15, consistent with the expected $O(p^{8})$ scaling.This shows the dramatic error suppression that should eventually enable large scale fault-tolerant quantum computers, provided we can reach similar error suppression factors in surface codes.

## V Real-time decoding

In addition to a high-fidelity processor, fault-tolerant quantum computing also requires a classical coprocessor that can decode errors in real time.This is because some logical operations are non-deterministic; they depend on logical measurement outcomes that must be correctly interpreted on the fly[23].If the decoder cannot process measurements fast enough, an increasing backlog of syndrome information can cause an exponential blow-up in computation time.Real-time decoding is particularly challenging for superconducting processors due to their speed.The throughput of transmitting, processing, and decoding the syndrome information in each cycle must keep pace with the fast error correcting cycle time of 1.1 µs.Using our 72-qubit processor as a platform, we demonstrate below-threshold performance alongside this vital module in the fault-tolerant quantum computing stack.

Our decoding system begins with our classical control electronics, where measurement signals are classified into bits then transmitted to a specialized workstation via low-latency Ethernet.Inside the workstation, measurements are converted into detections and then streamed to the real-time decoding software via a shared memory buffer.We employ a specialized version of the Sparse Blossom algorithm[42] optimized to quickly resolve local configurations of errors common in surface code decoding, using a parallelization strategy similar to Ref.[43].The decoder operates on a constant-sized graph buffer which emulates the section of the error graph being decoded at any instant, but which does not grow with the total number of cycles used in the experiment.Different threads are responsible for different spacetime regions of the graph, processing their requisite syndrome information as it is streamed in[44, 45, 43, 46].These results are fused until a global minimum-weight perfect matching is found.The streaming decoding algorithm is illustrated in Fig.4a-b.We also use a greedy edge reweighting strategy to increase accuracy by accounting for correlations induced by $Y$-type errors[29, 47].

In Fig.4d, we report the decoder latency, which we define as the time between the decoding software receiving the final cycle of syndrome measurements and the time when the decoder returns its correction.For our distance-5 surface code, we test different problem sizes by increasing the number of error correction cycles up to $10^{6}$.We observe that the average latency remains roughly constant at a net average of $63\pm 17$ µs independent of the length of the experiment (up to 1.1 seconds), indicating that the decoding problem is being processed in real time.This latency will eventually determine the reaction time of the logical processor when enacting non-Clifford gates, but does not yet include feedback into the logical circuit.

Importantly, we are able to maintain below-threshold performance even under the strict timing requirements imposed by real-time decoding.We run a dedicated experiment on our 72-qubit processor to compare real-time decoding to high-accuracy offline neural network decoding of the same data, with the results shown in Fig.4c.Our real-time decoder achieves $\varepsilon_{5}=0.35\%\pm 0.01\%$ and $\Lambda=2.0\pm 0.1$ using a device-data-independent prior.Meanwhile, the neural network decoder achieves $\varepsilon_{5}=0.269\%\pm 0.008\%$ and $\Lambda=2.18\pm 0.09$ when later decoding offline.The modest reduction in accuracy when comparing the real-time decoder to an offline decoder is expected as the real-time decoder must operate significantly faster.It requires a throughput of less than 1.1 µs per cycle compared to the neural network’s 24 µs per cycle[27].However, we do expect that many of our high-accuracy decoding methods can eventually be made real-time by introducing techniques like layered or windowed decoding[44, 45, 28].

## VI Outlook

In this work, we have demonstrated a below-threshold surface code memory.Each time the code distance increases by two, the logical error per cycle is reduced by more than half, culminating in a distance-7 logical lifetime more than double its best constituent physical qubit lifetime.This signature of exponential logical error suppression with code distance forms the foundation of running large scale quantum algorithms with error correction.

Our error-corrected processors also demonstrate other key advances towards fault-tolerant quantum computing.We achieve repeatable performance over several hours and run experiments up to $10^{6}$ cycles without deteriorating performance, both of which are necessary for future large scale fault-tolerant algorithms.Furthermore, we have engineered a real-time decoding system with only a modest reduction in accuracy compared to our offline decoders.

Even so, many challenges remain ahead of us.Although we might in principle achieve low logical error rates by scaling up our current processors, it would be resource intensive in practice.Extrapolating the projections in Fig.1d, achieving a $10^{-6}$ error rate would require a distance-27 logical qubit using 1457 physical qubits.Scaling up will also bring additional challenges in real-time decoding as the syndrome measurements per cycle increase quadratically with code distance.Our repetition code experiments also identify a noise floor at an error rate of $10^{-10}$ caused by correlated bursts of errors.Identifying and mitigating this error mechanism will be integral to running larger quantum algorithms.

However, quantum error correction also provides us exponential leverage in reducing logical errors with processor improvements.For example, reducing physical error rates by a factor of two would improve the distance-27 logical performance by four orders of magnitude, well into algorithmically-relevant error rates[11, 12].We further expect these overheads will reduce with advances in error correction protocols[48, 49, 50, 51, 52, 53, 54] and decoding[55, 56, 57].

The purpose of quantum error correction is to enable large scale quantum algorithms.While this work focuses on building a robust memory,additional challenges will arise in logical computation[58, 59].On the classical side, we must ensure that software elements including our calibration protocols, real-time decoders, and logical compilers can scale to the sizes and complexities needed to run multi-surface-code operations[60].With below-threshold surface codes, we have demonstrated processor performance that can scale in principle, but which we must now scale in practice.

## VII Author Contributions

The Google Quantum AI team conceived and designed the experiment. The theory and experimental teams at Google Quantum AI developed the data analysis, modeling and metrological tools that enabled the experiment, built the system, performed the calibrations, and collected the data. All authors wrote and revised the manuscript and the Supplementary Information.

## VIII Acknowledgements

We are grateful to S.Brin, S.Pichai, R.Porat, and J.Manyika for their executive sponsorship of the Google Quantum AI team, and for their continued engagement and support.

## IX Ethics Declarations

The authors declare no competing interests.

## X Additional Information

Supplementary Information is available for this paper.Correspondence and requests for materials should be addressed to H. Neven (neven@google.com).

## XI Data Availability

The data that support the findings of this study are availableathttps://doi.org/10.5281/zenodo.13273331.

Google Quantum AI and Collaborators

Rajeev Acharya1,Laleh Aghababaie-Beni1,Igor Aleiner1,Trond I.Andersen1,Markus Ansmann1,Frank Arute1,Kunal Arya1,Abraham Asfaw1,Nikita Astrakhantsev1,Juan Atalaya1,Ryan Babbush1,Dave Bacon1,Brian Ballard1,Joseph C.Bardin1, 2,Johannes Bausch3,Andreas Bengtsson1,Alexander Bilmes1,Sam Blackwell3,Sergio Boixo1,Gina Bortoli1,Alexandre Bourassa1,Jenna Bovaird1,Leon Brill1,Michael Broughton1,David A.Browne1,Brett Buchea1,Bob B.Buckley1,David A.Buell1,Tim Burger1,Brian Burkett1,Nicholas Bushnell1,Anthony Cabrera1,Juan Campero1,Hung-Shen Chang1,Yu Chen1,Zijun Chen1,Ben Chiaro1,Desmond Chik1,Charina Chou1,Jahan Claes1,Agnetta Y.Cleland1,Josh Cogan1,Roberto Collins1,Paul Conner1,William Courtney1,Alexander L.Crook1,Ben Curtin1,Sayan Das1,Alex Davies3,Laura DeLorenzo1,Dripto M.Debroy1,Sean Demura1,Michel Devoret1, 4,Agustin DiPaolo1,Paul Donohoe1,Ilya Drozdov1, 5,Andrew Dunsworth1,Clint Earle1,Thomas Edlich3,Alec Eickbusch1,Aviv Moshe Elbag1,Mahmoud Elzouka1,Catherine Erickson1,Lara Faoro1,Edward Farhi1,Vinicius S.Ferreira1,Leslie FloresBurgos1,Ebrahim Forati1,Austin G.Fowler1,Brooks Foxen1,Suhas Ganjam1,Gonzalo Garcia1,Robert Gasca1,Élie Genois1,William Giang1,Craig Gidney1,Dar Gilboa1,Raja Gosula1,Alejandro GrajalesDau1,Dietrich Graumann1,Alex Greene1,Jonathan A.Gross1,Steve Habegger1,John Hall1,Michael C.Hamilton1, 6,Monica Hansen1,Matthew P.Harrigan1,Sean D.Harrington1,Francisco J. H.Heras3,Stephen Heslin1,Paula Heu1,Oscar Higgott1,Gordon Hill1,Jeremy Hilton1,George Holland3,Sabrina Hong1,Hsin-Yuan Huang1,Ashley Huff1,William J.Huggins1,Lev B.Ioffe1,Sergei V.Isakov1,Justin Iveland1,Evan Jeffrey1,Zhang Jiang1,Cody Jones1,Stephen Jordan1,Chaitali Joshi1,Pavol Juhas1,Dvir Kafri1,Hui Kang1,Amir H.Karamlou1,Kostyantyn Kechedzhi1,Julian Kelly1,Trupti Khaire1,Tanuj Khattar1,Mostafa Khezri1,Seon Kim1,Paul V.Klimov1,Andrey R.Klots1,Bryce Kobrin1,Pushmeet Kohli3,Alexander N.Korotkov1,Fedor Kostritsa1,Robin Kothari1,Borislav Kozlovskii3,John Mark Kreikebaum1,Vladislav D.Kurilovich1,Nathan Lacroix1, 7,David Landhuis1,Tiano Lange-Dei1,Brandon W.Langley1,Pavel Laptev1,Kim-Ming Lau1,Loïck LeGuevel1,Justin Ledford1,Kenny Lee1,Yuri D.Lensky1,Shannon Leon1,Brian J.Lester1,Wing Yan Li1,Yin Li3,Alexander T.Lill1,Wayne Liu1,William P.Livingston1,Aditya Locharla1,Erik Lucero1,Daniel Lundahl1,Aaron Lunt1,Sid Madhuk1,Fionn D.Malone1,Ashley Maloney1,Salvatore Mandrà1,Leigh S.Martin1,Steven Martin1,Orion Martin1,Cameron Maxfield1,Jarrod R.McClean1,Matt McEwen1,Seneca Meeks1,Anthony Megrant1,Xiao Mi1,Kevin C.Miao1,Amanda Mieszala1,Reza Molavi1,Sebastian Molina1,Shirin Montazeri1,Alexis Morvan1,Ramis Movassagh1,Wojciech Mruczkiewicz1,Ofer Naaman1,Matthew Neeley1,Charles Neill1,Ani Nersisyan1,Hartmut Neven1,Michael Newman1,Jiun How Ng1,Anthony Nguyen1,Murray Nguyen1,Chia-Hung Ni1,Thomas E.O’Brien1,William D.Oliver1, 8, 9, 10,Alex Opremcak1,Kristoffer Ottosson1,Andre Petukhov1,Alex Pizzuto1,John Platt1,Rebecca Potter1,Orion Pritchard1,Leonid P.Pryadko1, 11,Chris Quintana1,Ganesh Ramachandran1,Matthew J.Reagor1,David M.Rhodes1,Gabrielle Roberts1,Eliott Rosenberg1,Emma Rosenfeld1,Pedram Roushan1,Nicholas C.Rubin1,Negar Saei1,Daniel Sank1,Kannan Sankaragomathi1,Kevin J.Satzinger1,Henry F.Schurkus1,Christopher Schuster1,Andrew W.Senior3,Michael J.Shearn1,Aaron Shorter1,Noah Shutty1,Vladimir Shvarts1,Shraddha Singh1, 12, 13,Volodymyr Sivak1,Jindra Skruzny1,Spencer Small1,Vadim Smelyanskiy1,W.Clarke Smith1,Rolando D.Somma1,Sofia Springer1,George Sterling1,Doug Strain1,Jordan Suchard1,Aaron Szasz1,Alex Sztein1,Douglas Thor1,Alfredo Torres1,M.Mert Torunbalci1,Abeer Vaishnav1,Justin Vargas1,Sergey Vdovichev1,Guifre Vidal1,Benjamin Villalonga1,Catherine VollgraffHeidweiller1,Steven Waltman1,Shannon X.Wang1,Brayden Ware1,Kate Weber1,Theodore White1,Kristi Wong1,Bryan W.K.Woo1,Cheng Xing1,Z.Jamie Yao1,Ping Yeh1,Bicheng Ying1,Juhwan Yoo1,Noureldin Yosri1,Grayson Young1,Adam Zalcman1,Yaxing Zhang1,Ningfeng Zhu1,Nicholas Zobrist1

${}^{\textrm{\scriptsize 1}}$ Google Research

${}^{\textrm{\scriptsize 2}}$ Department of Electrical and Computer Engineering, University of Massachusetts, Amherst, MA

${}^{\textrm{\scriptsize 3}}$ Google DeepMind

${}^{\textrm{\scriptsize 4}}$ Department of Physics, University of California, Santa Barbara, CA

${}^{\textrm{\scriptsize 5}}$ Department of Physics, University of Connecticut, Storrs, CT

${}^{\textrm{\scriptsize 6}}$ Department of Electrical and Computer Engineering, Auburn University, Auburn, AL

${}^{\textrm{\scriptsize 7}}$ Department of Physics, ETH Zurich, Switzerland

${}^{\textrm{\scriptsize 8}}$ Research Laboratory of Electronics, Massachusetts Institute of Technology, Cambridge, MA

${}^{\textrm{\scriptsize 9}}$ Department of Electrical Engineering and Computer Science, Massachusetts Institute of Technology, Cambridge, MA

${}^{\textrm{\scriptsize 10}}$ Department of Physics, Massachusetts Institute of Technology, Cambridge, MA

${}^{\textrm{\scriptsize 11}}$ Department of Physics and Astronomy, University of California, Riverside, CA

${}^{\textrm{\scriptsize 12}}$ Yale Quantum Institute, Yale University, New Haven, CT

${}^{\textrm{\scriptsize 13}}$ Departments of Applied Physics and Physics, Yale University, New Haven, CT

## References

- [1]Shor, P.W.Scheme for reducing decoherence in quantum computer memory.
*Physical Review A*52, R2493 (1995). - [2]Gottesman, D.
*Stabilizer codes and quantum error correction*(California Institute of Technology, 1997). - [3]Dennis, E., Kitaev, A.Y., Landahl, A. & Preskill, J.Topological quantum memory.
*Journal of Mathematical Physics*43, 4452–4505 (2002). - [4]Kitaev, A.Y.Fault-tolerant quantum computation by anyons.
*Annals of Physics*303, 2–30 (2003). - [5]Aspuru-Guzik, A., Dutoi, A.D., Love, P.J. & Head-Gordon, M.Simulated quantum computation of molecular energies.
*Science*309, 1704–1707 (2005). - [6]Lloyd, S.Universal quantum simulators.
*Science*273, 1073–1078 (1996). - [7]Shor, P.W.Polynomial-time algorithms for prime factorization and discrete logarithms on a quantum computer.
*SIAM Review*41, 303–332 (1999). - [8]Farhi, E.
*etal.*A quantum adiabatic evolution algorithm applied to random instances of an NP-complete problem.*Science*292, 472–475 (2001). - [9]McKay, D.C.
*etal.*Benchmarking quantum processor performance at scale.*arXiv preprint arXiv:2311.05933*(2023). - [10]DeCross, M.
*etal.*The computational power of random quantum circuits in arbitrary geometries.*arXiv preprint arXiv:2406.02501*(2024). - [11]Campbell, E.T.Early fault-tolerant simulations of the Hubbard model.
*Quantum Science and Technology*7, 015007 (2021). - [12]Kivlichan, I.D.
*etal.*Improved fault-tolerant quantum simulation of condensed-phase correlated electrons via Trotterization.*Quantum*4, 296 (2020). - [13]Fowler, A.G., Mariantoni, M., Martinis, J.M. & Cleland, A.N.Surface codes: Towards practical large-scale quantum computation.
*Physical Review A—Atomic, Molecular, and Optical Physics*86, 032324 (2012). - [14]Ryan-Anderson, C.
*etal.*Realization of real-time fault-tolerant quantum error correction.*Physical Review X*11, 041058 (2021). - [15]Krinner, S.
*etal.*Realizing repeated quantum error correction in a distance-three surface code.*Nature*605, 669–674 (2022). - [16]Sivak, V.V.
*etal.*Real-time quantum error correction beyond break-even.*Nature*616, 50–55 (2023). - [17]Google Quantum AI.Suppressing quantum errors by scaling a surface code logical qubit.
*Nature*614, 676–681 (2023). - [18]Bluvstein, D.
*etal.*Logical quantum processor based on reconfigurable atom arrays.*Nature*626, 58–65 (2024). - [19]Gupta, R.S.
*etal.*Encoding a magic state with beyond break-even fidelity.*Nature*625, 259–263 (2024). - [20]DaSilva, M.
*etal.*Demonstration of logical qubits and repeated error correction with better-than-physical error rates.*arXiv preprint arXiv:2404.02280*(2024). - [21]Gidney, C. & Ekerå, M.How to factor 2048 bit RSA integers in 8 hours using 20 million noisy qubits.
*Quantum*5, 433 (2021). - [22]Terhal, B.M. & Burkard, G.Fault-tolerant quantum computation for local non-Markovian noise.
*Physical Review A—Atomic, Molecular, and Optical Physics*71, 012336 (2005). - [23]Terhal, B.M.Quantum error correction for quantum memories.
*Reviews of Modern Physics*87, 307–346 (2015). - [24]Google Quantum AI and Collaborators.Supplementary Information for “Quantum error correction below the surface code threshold”.
- [25]Koch, J.
*etal.*Charge-insensitive qubit design derived from the Cooper pair box.*Physical Review A—Atomic, Molecular, and Optical Physics*76, 042319 (2007). - [26]Arute, F.
*etal.*Quantum supremacy using a programmable superconducting processor.*Nature*574, 505–510 (2019). - [27]Bausch, J.
*etal.*Learning to decode the surface code with a recurrent, transformer-based neural network.*arXiv preprint arXiv:2310.05900*(2023). - [28]Shutty, N., Newman, M. & Villalonga, B.Efficient near-optimal decoding of the surface code through ensembling.
*arXiv preprint arXiv:2401.12434*(2024). - [29]Fowler, A.G.Optimal complexity correction of correlated errors in the surface code.
*arXiv preprint arXiv:1310.0863*(2013). - [30]Jones, C.Improved accuracy for decoding surface codes with matching synthesis.
*arXiv preprint arXiv:2408.12135*(2024). - [31]Sivak, V., Newman, M. & Klimov, P.Optimization of decoder priors for accurate quantum error correction.
*arXiv preprint arXiv:2406.02700*(2024). - [32]BonillaAtaides, J.P., Tuckett, D.K., Bartlett, S.D., Flammia, S.T. & Brown, B.J.The XZZX surface code.
*Nature Communications*12, 2172 (2021). - [33]Miao, K.C.
*etal.*Overcoming leakage in quantum error correction.*Nature Physics*19, 1780–1786 (2023). - [34]Hesner, I., Hetényi, B. & Wootton, J.R.Using detector likelihood for benchmarking quantum error correction.
*arXiv preprint arXiv:2408.02082*(2024). - [35]Klimov, P.V.
*etal.*Optimizing quantum gates towards the scale of logical qubits.*Nature Communications*15, 2442 (2024). - [36]Ofek, N.
*etal.*Extending the lifetime of a quantum bit with error correction in superconducting circuits.*Nature*536, 441–445 (2016). - [37]Ni, Z.
*etal.*Beating the break-even point with a discrete-variable-encoded logical qubit.*Nature*616, 56–60 (2023). - [38]Chen, Z.
*etal.*Exponential suppression of bit or phase flip errors with repetitive error correction.*Nature*595, 383–387 (2021). - [39]Varbanov, B.M.
*etal.*Leakage detection for a transmon-based surface code.*npj Quantum Information*6, 102 (2020). - [40]McEwen, M.
*etal.*Resisting high-energy impact events through gap engineering in superconducting qubit arrays.*arXiv preprint arXiv:2402.15644*(2024). - [41]Strikis, A., Benjamin, S.C. & Brown, B.J.Quantum computing is scalable on a planar array of qubits with fabrication defects.
*Physical Review Applied*19, 064081 (2023). - [42]Higgott, O. & Gidney, C.Sparse Blossom: correcting a million errors per core second with minimum-weight matching.
*arXiv preprint arXiv:2303.15933*(2023). - [43]Wu, Y. & Zhong, L.Fusion Blossom: Fast MWPM decoders for QEC.In
*2023 IEEE International Conference on Quantum Computing and Engineering (QCE)*, vol.1, 928–938 (IEEE, 2023). - [44]Skoric, L., Browne, D.E., Barnes, K.M., Gillespie, N.I. & Campbell, E.T.Parallel window decoding enables scalable fault tolerant quantum computation.
*Nature Communications*14, 7040 (2023). - [45]Tan, X., Zhang, F., Chao, R., Shi, Y. & Chen, J.Scalable surface-code decoders with parallelization in time.
*PRX Quantum*4, 040344 (2023). - [46]Bombín, H.
*etal.*Modular decoding: parallelizable real-time decoding for quantum computers.*arXiv preprint arXiv:2303.04846*(2023). - [47]Paler, A. & Fowler, A.G.Pipelined correlated minimum weight perfect matching of the surface code.
*Quantum*7, 1205 (2023). - [48]Litinski, D. & Nickerson, N.Active volume: An architecture for efficient fault-tolerant quantum computers with limited non-local connections.
*arXiv preprint arXiv:2211.15465*(2022). - [49]Chamberland, C. & Campbell, E.T.Universal quantum computing with twist-free and temporally encoded lattice surgery.
*PRX Quantum*3, 010331 (2022). - [50]Bravyi, S.
*etal.*High-threshold and low-overhead fault-tolerant quantum memory.*Nature*627, 778–782 (2024). - [51]Xu, Q.
*etal.*Constant-overhead fault-tolerant quantum computation with reconfigurable atom arrays.*Nature Physics*1–7 (2024). - [52]Gidney, C., Newman, M., Brooks, P. & Jones, C.Yoked surface codes.
*arXiv preprint arXiv:2312.04522*(2023). - [53]Gidney, C.Inplace access to the surface code Y basis.
*Quantum*8, 1310 (2024). - [54]Cain, M.
*etal.*Correlated decoding of logical algorithms with transversal gates.*arXiv preprint arXiv:2403.03272*(2024). - [55]Smith, S.C., Brown, B.J. & Bartlett, S.D.Local predecoder to reduce the bandwidth and latency of quantum error correction.
*Physical Review Applied*19, 034050 (2023). - [56]Barber, B.
*etal.*A real-time, scalable, fast and highly resource efficient decoder for a quantum computer.*arXiv preprint arXiv:2309.05558*(2023). - [57]Liyanage, N., Wu, Y., Tagare, S. & Zhong, L.FPGA-based distributed union-find decoder for surface codes.
*arXiv preprint arXiv:2406.08491*(2024). - [58]Gidney, C.Stability experiments: the overlooked dual of memory experiments.
*Quantum*6, 786 (2022). - [59]Lin, S.F., Peterson, E.C., Sankar, K. & Sivarajah, P.Spatially parallel decoding for multi-qubit lattice surgery.
*arXiv preprint arXiv:2403.01353*(2024). - [60]Bombin, H.
*etal.*Logical blocks for fault-tolerant topological quantum computation.*PRX Quantum*4, 020303 (2023).