PaperlayerView exact revision on arXiv

Source-linked AI summary

Quantum error correction below the surface code threshold

Rajeev Acharya, Laleh Aghababaie-Beni, Igor Aleiner, Trond I. Andersen, Markus Ansmann, Frank Arute, Kunal Arya, Abraham Asfaw, Nikita Astrakhantsev, Juan Atalaya, Ryan Babbush, Dave Bacon, Brian Ballard, Joseph C. Bardin, Johannes Bausch, Andreas Bengtsson, Alexander Bilmes, Sam Blackwell, Sergio Boixo, Gina Bortoli, Alexandre Bourassa, Jenna Bovaird, Leon Brill, Michael Broughton, David A. Browne, Brett Buchea, Bob B. Buckley, David A. Buell, Tim Burger, Brian Burkett, Nicholas Bushnell, Anthony Cabrera, Juan Campero, Hung-Shen Chang, Yu Chen, Zijun Chen, Ben Chiaro, Desmond Chik, Charina Chou, Jahan Claes, Agnetta Y. Cleland, Josh Cogan, Roberto Collins, Paul Conner, William Courtney, Alexander L. Crook, Ben Curtin, Sayan Das, Alex Davies, Laura De Lorenzo, Dripto M. Debroy, Sean Demura, Michel Devoret, Agustin Di Paolo, Paul Donohoe, Ilya Drozdov, Andrew Dunsworth, Clint Earle, Thomas Edlich, Alec Eickbusch, Aviv Moshe Elbag, Mahmoud Elzouka, Catherine Erickson, Lara Faoro, Edward Farhi, Vinicius S. Ferreira, Leslie Flores Burgos, Ebrahim Forati, Austin G. Fowler, Brooks Foxen, Suhas Ganjam, Gonzalo Garcia, Robert Gasca, Élie Genois, William Giang, Craig Gidney, Dar Gilboa, Raja Gosula, Alejandro Grajales Dau, Dietrich Graumann, Alex Greene, Jonathan A. Gross, Steve Habegger, John Hall, Michael C. Hamilton, Monica Hansen, Matthew P. Harrigan, Sean D. Harrington, Francisco J. H. Heras, Stephen Heslin, Paula Heu, Oscar Higgott, Gordon Hill, Jeremy Hilton, George Holland, Sabrina Hong, Hsin-Yuan Huang, Ashley Huff, William J. Huggins, Lev B. Ioffe, Sergei V. Isakov, Justin Iveland, Evan Jeffrey, Zhang Jiang, Cody Jones, Stephen Jordan, Chaitali Joshi, Pavol Juhas, Dvir Kafri, Hui Kang, Amir H. Karamlou, Kostyantyn Kechedzhi, Julian Kelly, Trupti Khaire, Tanuj Khattar, Mostafa Khezri, Seon Kim, Paul V. Klimov, Andrey R. Klots, Bryce Kobrin, Pushmeet Kohli, Alexander N. Korotkov, Fedor Kostritsa, Robin Kothari, Borislav Kozlovskii, John Mark Kreikebaum, Vladislav D. Kurilovich, Nathan Lacroix, David Landhuis, Tiano Lange-Dei, Brandon W. Langley, Pavel Laptev, Kim-Ming Lau, Loïck Le Guevel, Justin Ledford, Kenny Lee, Yuri D. Lensky, Shannon Leon, Brian J. Lester, Wing Yan Li, Yin Li, Alexander T. Lill, Wayne Liu, William P. Livingston, Aditya Locharla, Erik Lucero, Daniel Lundahl, Aaron Lunt, Sid Madhuk, Fionn D. Malone, Ashley Maloney, Salvatore Mandrá, Leigh S. Martin, Steven Martin, Orion Martin, Cameron Maxfield, Jarrod R. McClean, Matt McEwen, Seneca Meeks, Anthony Megrant, Xiao Mi, Kevin C. Miao, Amanda Mieszala, Reza Molavi, Sebastian Molina, Shirin Montazeri, Alexis Morvan, Ramis Movassagh, Wojciech Mruczkiewicz, Ofer Naaman, Matthew Neeley, Charles Neill, Ani Nersisyan, Hartmut Neven, Michael Newman, Jiun How Ng, Anthony Nguyen, Murray Nguyen, Chia-Hung Ni, Thomas E. O'Brien, William D. Oliver, Alex Opremcak, Kristoffer Ottosson, Andre Petukhov, Alex Pizzuto, John Platt, Rebecca Potter, Orion Pritchard, Leonid P. Pryadko, Chris Quintana, Ganesh Ramachandran, Matthew J. Reagor, David M. Rhodes, Gabrielle Roberts, Eliott Rosenberg, Emma Rosenfeld, Pedram Roushan, Nicholas C. Rubin, Negar Saei, Daniel Sank, Kannan Sankaragomathi, Kevin J. Satzinger, Henry F. Schurkus, Christopher Schuster, Andrew W. Senior, Michael J. Shearn, Aaron Shorter, Noah Shutty, Vladimir Shvarts, Shraddha Singh, Volodymyr Sivak, Jindra Skruzny, Spencer Small, Vadim Smelyanskiy, W. Clarke Smith, Rolando D. Somma, Sofia Springer, George Sterling, Doug Strain, Jordan Suchard, Aaron Szasz, Alex Sztein, Douglas Thor, Alfredo Torres, M. Mert Torunbalci, Abeer Vaishnav, Justin Vargas, Sergey Vdovichev, Guifre Vidal, Benjamin Villalonga, Catherine Vollgraff Heidweiller, Steven Waltman, Shannon X. Wang, Brayden Ware, Kate Weber, Theodore White, Kristi Wong, Bryan W. K. Woo, Cheng Xing, Z. Jamie Yao, Ping Yeh, Bicheng Ying, Juhwan Yoo, Noureldin Yosri, Grayson Young, Adam Zalcman, Yaxing Zhang, Ningfeng Zhu, Nicholas Zobrist

arXiv:2408.13687v1quant-ph

TL;DR

Quantum error correction requires physical operations below a threshold for logical errors to decrease with code size, while fast decoding remains challenging. This work demonstrates below-threshold surface-code memories, including real-time decoding, and finds that increasing distance by two reduces logical error per cycle by more than half.

  • Problem

    Evidence for below-threshold logical error suppression and sufficiently fast real-time decoding remains limited, despite their importance for practical quantum computing.

  • Method

    The authors implement distance-5 and distance-7 surface-code memories on superconducting processors and test high-distance repetition codes for logical error floors.

  • Results

    Increasing code distance by two reduces logical error per cycle by more than half, and the distance-7 logical lifetime exceeds its best constituent physical qubit lifetime by more than twofold.

  • Takeaways & Limitations

    The observed suppression with code distance provides a foundation for running large-scale quantum algorithms with error correction.

  • Takeaways & Limitations

    Scaling to lower logical error rates would be resource intensive, while correlated error bursts create a noise floor near 10^-10.

Abstract

from arXiv · show

Quantum error correction 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 $Λ$ = 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.

I. INTRODUCTION

Quantum error correction is needed because current many-qubit platforms remain far from application-level error rates, while fault-tolerant computing also requires stability, leakage removal, and real-time decoding. This work realizes below-threshold surface codes on two superconducting processors, including an integrated real-time decoder and performance with Λ > 2 through distance-7.

  • Motivation: 99.9% entangling-gate fidelity remains far above the < 10−10 error rates needed for many applications, motivating quantum error correction.Quantum information is fragile, and quantum operations are error-prone.
  • Surface-code principle: p ≪ p_thr yields exponential logical-error suppression with code distance, characterized by Λ = ε_d/ε_d+2 ≈ p_thr/p.Here, p and ε_d denote physical and logical error rates, while p_thr is the code threshold error rate.
  • Fault-tolerance requirements: Fault-tolerant operation requires hours-long stability, active removal of correlated errors such as leakage, and syndrome decoding as fast as information is generated.Superconducting qubits operate on timescales from tens to hundreds of nanoseconds, creating a decoding-speed challenge.
  • Contributions: Λ > 2 was demonstrated through distance-5 and distance-7 codes on two superconducting processors, using 72 and 105 qubits, respectively.The distance-5 code included an integrated real-time decoder; the distance-7 code used a separate 105-qubit processor with similar performance.

II. A SURFACE CODE MEMORY BELOW THRESHOLD

The experiment demonstrates below-threshold operation of a distance-7 surface code memory on a 105-qubit processor, with logical errors suppressed as code distance increases. The distance-7 logical qubit already achieves more than double the lifetime of its constituent physical qubits.

  • Device and operation: 105-qubit processor implements a distance-7 surface code comprising 49 data, 48 measure, and 4 leakage-removal qubits.The code repeatedly extracts parity information and performs data-qubit leakage removal before measuring the logical state.
  • Logical performance: Λ = 2.04±0.02 and ε7 = (1.71 ± 0.03) × 10^-3 with ensembled matching synthesis also show error suppression.This provides a second offline decoding result using correlated minimum-weight perfect matching with matching synthesis.
  • Device and operation: pdet = (7.7%, 8.5%, 8.7%) for d = (3, 5, 7), with larger-code detection probabilities attributed to finite-size effects and parasitic couplings.The authors expect both effects to saturate at larger processor sizes.
  • Logical performance: Λ = 2.14 ± 0.02 and ε7 = (1.43 ± 0.03) × 10^-3 with the neural network decoder demonstrate strong distance-dependent error suppression.Logical performance is fitted using logical error per cycle averaged over X and Z bases.
  • Logical performance: More than double the lifetime of constituent physical qubits is achieved by the distance-7 logical qubit.The paper notes that direct physical-versus-logical comparisons are subtle because their noise processes differ.

III. LOGICAL ERROR SENSITIVITY

The study probes how logical error responds to physical error, code distance, correlated noise, leakage, and temporal drift. These experiments reveal threshold behavior, identify dominant modeled error mechanisms, and show stability over hours-long timescales.

  • Physical-error and distance sensitivity: The processor exhibits characteristic threshold behavior in situ as logical performance is tested against injected physical errors and code distance.Experiments inject coherent errors into data and measure qubits, using detection probability as a proxy for total physical error rate.
  • Correlated-error budget: The error budget models gate and measurement noise alongside correlated leakage and stray CZ interactions that produce correlated ZZ and swap-like errors.For the 72-qubit processor, correlated matching on experimental data yields an error budget that overpredicts Λ by 20%.
  • Leakage sensitivity: Leakage sensitivity is measured by comparing distance-3 and distance-5 logical error probabilities with and without data-qubit leakage removal.Measure-qubit leakage is removed using multi-level reset, while DQLR transfers data-qubit leakage to measure or additional leakage-removal qubits.
  • Drift sensitivity: 16 measurements over 15 hours assess one distance-5 and four distance-3 codes on the 72-qubit processor, testing stability against drift.A frequency-optimization strategy forecasts TLS defect frequencies to help avoid qubit coupling to two-level systems.

IV. PROBING THE ULTRA-LOW ERROR REGIME WITH REPETITION CODES

Repetition-code experiments reach logical error rates far below the previously observed 10−6 floor, with strong suppression at distances 5–11. At distances d ≥ 15, rare correlated error bursts cause deviations from exponential scaling and define the remaining high-distance limitation.

  • Repetition-code experiments: 2 × 10^10 cycles over 5.5 hours tested distance-29 repetition codes on a 72-qubit processor, split evenly between bit- and phase-flip codes.The experiment used 1000 cycles of error correction per shot.
  • Low-error scaling: Λ = 8.4±0.1 between d = 5 and 11, with logical error per cycle suppressed far below 10−6, breaking the previous error floor.The mitigation of high-energy impact failures is attributed to gap-engineered Josephson junctions.
  • High-distance limitations: Six large error bursts occurred during 2 × 10^10 cycles, approximately once an hour rather than every few seconds, and caused the highest-distance failures.The bursts differ from previously observed high-energy impact events and are associated with deviations from exponential suppression at d ≥ 15.
  • High-distance limitations: Around 400 µs exponential decay characterizes the bursts, whose unknown cause remains a vital mitigation target for fault-tolerant quantum computing.Long repetition codes are identified as a tool for discovering error mechanisms at the logical noise floor.
  • Low-error scaling: O(p(d+1)/2) error suppression agrees with measured scaling versus physical error and code distance; halving detection probability produces a factor of 250 reduction in logical error.These measurements extend the scan to higher distances and lower logical errors using coherent error injection.

V. REAL-TIME DECODING

The paper develops a streaming real-time decoder that processes syndrome data across spacetime regions and maintains below-threshold performance. For the distance-5 code, average decoder latency remains 63 ± 17 µs across experiments up to 10^6 cycles.

  • Motivation: Real-time decoding is required because nondeterministic logical operations depend on measurement outcomes interpreted during computation.Insufficient decoding speed can create a syndrome-information backlog and an exponential increase in computation time.
  • Decoder implementation: Measurements are classified, transmitted over low-latency Ethernet, converted into detections, and streamed through shared memory to parallel decoding threads.The threads process different spacetime graph regions as syndrome information arrives.
  • Decoder implementation: Streaming outputs are fused into a global minimum-weight perfect matching, with greedy edge reweighting improving accuracy for correlations from Y-type errors.The streaming decoding algorithm is illustrated in Fig. 4a-b.
  • Latency: 63 ± 17 µs average latency remains roughly constant for the distance-5 code as experiments reach 10^6 error-correction cycles.The latency is independent of experiment length up to 1.1 seconds.
  • Performance: ε5 = 0.35% ± 0.01% and Λ = 2.0 ± 0.1 demonstrate below-threshold performance with real-time decoding on the 72-qubit processor.The comparison uses a device-data-independent prior and the same data is also decoded offline with a high-accuracy neural network.

VI. OUTLOOK

The work demonstrates below-threshold surface-code memories with exponential logical-error suppression and real-time decoding, while identifying substantial resource, decoding, and computation challenges for scaling to large quantum algorithms.

  • Demonstrated advances: Increasing code distance by two reduces logical error per cycle by more than half, culminating in a distance-7 lifetime more than twice that of its best physical qubit.This exponential suppression underpins the prospect of large-scale error-corrected quantum algorithms.
  • Demonstrated advances: Several-hour operation and experiments up to 10^6 cycles show repeatable performance without deterioration.These capabilities are identified as necessary for future large-scale fault-tolerant algorithms.
  • Demonstrated advances: Real-time decoding achieves only a modest accuracy reduction compared with offline decoding.The processor therefore combines below-threshold memory performance with engineered streaming decoding.
  • Scaling challenges: A 10^-6 error rate would require a distance-27 logical qubit using 1457 physical qubits, making practical scaling resource intensive.Scaling also introduces additional real-time decoding challenges and requires identifying and mitigating the relevant error mechanism.
  • Scaling opportunities: Halving physical error rates would improve distance-27 logical performance by four orders of magnitude, while advances in protocols and decoding may reduce overheads.This illustrates the exponential leverage that processor improvements provide for reducing logical errors.
  • Scaling challenges: Large-scale algorithms will additionally require scalable logical computation, calibration, real-time decoding, and compilation for multi-surface-code operations.The work focuses on building a robust memory, while these software and logical-computation challenges remain.

VII. AUTHOR CONTRIBUTIONS · X. ADDITIONAL INFORMATION

The Google Quantum AI team conceived and designed the experiment, while theory and experimental teams developed the tools, built and calibrated the system, and collected data. All authors wrote and revised the manuscript and Supplementary Information.

  • VII. AUTHOR CONTRIBUTIONS: The Google Quantum AI team conceived and designed the experiment.
  • VII. AUTHOR CONTRIBUTIONS: Theory and experimental teams developed data-analysis, modeling, and metrological tools, built the system, performed calibrations, and collected data.
  • VII. AUTHOR CONTRIBUTIONS: All authors wrote and revised the manuscript and Supplementary Information.

XI. DATA AVAILABILITY … 1. Surface Code Simulation Details

The supplementary information documents the experiment’s hardware, decoder, simulation, and data-release methods. It details optimized control and decoding strategies, real-time system requirements, and noise modeling for surface-code simulations.

  • XI. DATA AVAILABILITY: The study’s findings are publicly available through a Zenodo repository, while the supplementary material identifies the authors and institutional affiliations.The data availability statement links to https://doi.org/10.5281/zenodo.13273331.
  • I. Gates and Readout: 25 ns XY rotations and 42 ns CZ gates were used on the 105-qubit processor, while the 72-qubit processor used 35 ns π and 18 ns π/2 rotations and 37 ns CZ gates.The measurement chain and readout pulse settings were jointly optimized for high-fidelity mid-circuit readout, and operation-error distributions were characterized for both processors.
  • A. Frequency Optimization: The Snake optimizer prioritizes coherence within the error-correction circuit and mitigates time-dependent TLS frequency collisions using historical T1 trajectories.The optimization model penalizes frequencies associated with reduced T1 and excludes forecast TLS-collision frequencies from allowed gate settings.
  • B. Decoder Priors: 1.14 times lower LER on average was achieved by ensembling than by correlated matching with the SI1000 prior on the distance-5 code.The neural-network decoder had the highest overall accuracy in one dataset, while Harmony was the strongest tested matching-based configuration.
  • C. Neural Network Decoder Details: The recurrent attention-based neural network processes one stabilizer-measurement cycle at a time and outputs a calibrated logical-error probability.Models are pretrained on synthetic SI1000 data, then fine-tuned using detector-error-model and experimental samples with temporal or cross-validation splits.
  • 1. Technical Requirements: Tinput < 10 µs was measured for the real-time decoding system, whose software latency remained roughly constant over one million cycles despite brief recoverable spikes.Real-time decoding must jointly satisfy accuracy, latency, and throughput; insufficient throughput causes syndrome backlog and exponential slowdown.
  • 2. Correlated Parallel Blossom: The real-time decoder combines correlation preweighting, block-based parallelization, and a constant-sized buffer storing 128 contiguous blocks.It is a multithreaded correlation-augmented minimum-weight perfect matching decoder using Sparse Blossom; simulations model decoherence, readout/reset errors, leakage, crosstalk, excess gate errors, and imperfect DQLR before Pauli+ sampling.

2. Surface Code Performance at Large Code Distances

Simulations extend surface-code performance analysis to larger distances, showing modest effects from non-uniform component errors, substantial gains from doubling component fidelity, and the importance of DQLR for continued suppression. They also identify a crossover where weak suppression eventually saturates and reverses.

  • Non-uniform component errors: Λ3/5 = 2.16, Λ5/7 = 2.2, Λ7/9 = 2.16, Λ9/11 = 2.12 and Λ11/13 = 2.01, indicating relatively small spread from non-uniform component errors.The simulations bootstrap measured component errors from the d = 5 surface-code grid and compare non-uniform with nearly uniform models.
  • Twice-better component errors: Λ ≈4.5 is the predicted logical error suppression factor when component errors are twice better than demonstrated.The forecast offers an alternative to reaching LER = 10^-6 with a minimum distance d = 27 requiring 1457 qubits.
  • Importance of DQLR: Λd/d+2 saturates to around 1 at large code distances without DQLR, whereas DQLR preserves exponential logical-error suppression.The simulations use experimental component-error parameters from the 72-qubit processor, with uniform errors except stray-coupling crosstalk.
  • Crossover regime: Λ3/5 ≤1.3 causes error suppression to diminish and eventually reverse with distance, while Λ3/5 ≥1.5 supports continued below-threshold suppression.The crossover shows that assuming distance-independent Λ can fail near Λ3/5 ≈1, even when finite-size simulations initially show suppression.

3. Surface Code 1/Λ Error Budget · B. Comparison to Physical Qubit Lifetime

The error budget identifies CZ-gate errors as the dominant contribution to 1/Λ, while the surface-code memory achieves a gain of G = 2.4±0.3 over the best physical qubit. The lifetime comparison uses an effective, uniformly sampled pure-state lifetime to compare qubits with different error channels.

  • 3. Surface Code 1/Λ Error Budget: About 60% of the 1/Λ budget comes from CZ-gate-related errors, followed by about 20% from data-qubit idle errors.Readout and reset errors are additional contributors; the sensitivities assume perfect DQLR and a correlated matching decoder.
  • 3. Surface Code 1/Λ Error Budget: Λ3/5 = 2.25 is predicted from the error-budget model, compared with Λ3/5 = 2.17 from directly simulated distance-3 and distance-5 logical error rates.The budget is constructed for the 72-qubit processor using device parameters and correlated matching decoding.
  • B. Comparison to Physical Qubit Lifetime: Average channel fidelity compares a quantum channel with the identity using uniform averaging over the qubit state space.The uniform average is equivalent to averaging over the six cardinal Bloch-sphere states, providing an experimental identity-channel fidelity protocol.
  • B. Comparison to Physical Qubit Lifetime: Different error channels produce different fidelity decay, so short-time decay is represented by an effective depolarization rate Γ and lifetime 1/Γ.This metric permits comparison among qubits with different error channels but does not favor extremely biased noise.
  • B. Comparison to Physical Qubit Lifetime: For a surface-code logical qubit, small per-cycle Pauli error probabilities are converted to continuous rates using γX ≈ pX/tc, γY ≈ pY/tc, and γZ ≈ pZ/tc.The logical channel is modeled as a Pauli channel with error probabilities pX, pY, and pZ per cycle, where tc is the cycle duration.
  • B. Comparison to Physical Qubit Lifetime: G = 2.4±0.3 demonstrates a beyond-break-even quantum memory relative to the qubit with the longest measured physical lifetime.The gain G is defined as the logical qubit’s effective-lifetime improvement over the best physical qubit, with break-even at G = 1.

V. Error Correction Experimental Details … VI. Uncertainty Analysis

The experiments characterize rare correlated events that limit high-distance repetition-code performance and detail the surface-code grids, datasets, and circuit methodology used for comparisons. A distance-29 repetition code reaches Λ > 8 with an apparent logical-error-per-cycle floor of 10−10, while smaller-code averaging and representative datasets support cross-distance analysis.

  • A. Low Probability Events in the Repetition Code: Λ > 8 and 10−10 mark the distance-29 repetition code’s apparent logical-error-per-cycle floor at large distances.This floor represents a four orders-of-magnitude improvement over the lowest logical error per cycle reported in previous experiments.
  • A. Low Probability Events in the Repetition Code: Correlated bursts show a sharp rise in detection-event probability followed by exponential decay to baseline over several shots.They account for all observed distance-27 logical errors and half of the distance-21 to distance-25 errors.
  • A. Low Probability Events in the Repetition Code: Once every hour, rare limiting events produce high-distance repetition-code errors during data acquisition.The high-distance regime is defined here as d > 19.
  • A. Low Probability Events in the Repetition Code: A single noisy detector can fire with rapidly increasing likelihood and remain highly active for 1-2 ms.The noisy detector varies between events, and an example is shown in Fig. S7.
  • B. Grid and Circuit Details: Distance-3 and distance-5 grids are placed on both processors, while several smaller codes are averaged to cover larger codes with minimal overlap.This comparison methodology extends the approach of Ref..
  • B. Grid and Circuit Details: Λ = 2.31 ± 0.02 is obtained from a representative logical-error-versus-cycles dataset on the 72-qubit processor.Related detection-event datasets include distance-3 and distance-5 codes, distance-29 repetition codes, and distance-3, distance-5, and distance-7 codes across the processors.
  • B. Grid and Circuit Details: Surface-code error-correction circuits are organized into layers of single- and two-qubit gates, dynamical decoupling, and measurement operations.A Pauli simulation of the 105-qubit device shows good agreement with measured detection probabilities for d = (3, 5, 7).
  • B. Grid and Circuit Details: Each code-and-cycle dataset uses 50,000 repetitions across 10 initialization bitstrings, with experiments interleaved across codes and numbers of cycles.The initialization set comprises 5 random bitstrings and their complements, and complementary bitstrings have opposite logical eigenvalues for odd-distance surface codes.

A. Logical Performance

Logical performance is quantified through decoder-dependent logical error per cycle and an error-suppression factor Λ fitted across code distances. Separate idle-basis fits yield distinct suppression factors for X- and Z-sensitive error mechanisms.

  • Logical Performance: εd depends on the decoding scheme, with values reported separately for the neural network decoder and the ensembled synthetic matcher Libra.The neural-network values are plotted in Fig. 1d, while specific grid- and basis-level values appear in Table S5.
  • Logical Performance: Λ is computed by linear regression of ln εd against (d + 1)/2, using the fitted slope to obtain Λ and its uncertainty.Logical error per cycle εd is extracted by fitting exponentials to pL versus cycle count t, while performance drift contributes beyond sampling uncertainty.
  • Logical Performance: Λx = 8.27 ± 0.02 and Λz = 8.55 ± 0.02 were obtained by fitting code distances d = 5 to 11 for separate idle bases.The overall value is defined as the mean of Λx and Λz, with uncertainty estimated from half their difference.

B. Logical Error per Cycle From One Point

Logical error per cycle is estimated from single-cycle-count experiments using a binomial model, with experiment lengths chosen to resolve the relevant error scales. The resulting estimates remain relatively constant across cycle counts, indicating no degradation for longer experiments.

  • Estimation method: 10 cycles are used for error-injection experiments to resolve high logical error ε_d ∼0.1, while repetition-code experiments use 1000 cycles to resolve ε_3 ∼10^-3.Experiment lengths are selected according to the logical-error scale being measured.
  • Estimation method: A binomial model estimates the logical error per cycle ε_d from a single point consisting of cycle count r and logical error fraction p_L.The estimate is formed from the observed logical error fraction at a specified number of rounds.
  • Uncertainty: 2 × 10^10 total cycles set a statistical floor for low-error experiments, making uncertainties more noticeable at higher-distance points.This effect occurs where relatively few errors are observed.
  • Consistency check: The one-point estimates remain relatively constant across different cycle counts, indicating that performance does not degrade for longer cycle counts.The estimates are computed for each cycle count and averaged over basis and grid.
Loading 2408.13687v1…