Suppressing quantum errors by scaling a surface code logical qubit

TL;DR

This work demonstrates the first experimental evidence that quantum error correction begins to improve logical performance as code distance increases, using a distance-5 surface code on a 72-qubit superconducting processor and comparing to distance-3 subcodes. The authors implement robust stabiliser measurements, advanced decoding (belief-matching and tensor networks), and leakage-aware noise modelling (Pauli+), achieving a distance-5 logical error per cycle of $\varepsilon_5 = 2.914\% \pm 0.016\%$ versus $\varepsilon_3 = 3.028\% \pm 0.023\%$ on 25 cycles, and a distance-25 repetition code that reaches a logical error per round floor near $10^{-6}$. They develop a comprehensive error-budget framework to identify dominant error sources (CZ, data-qubit decoherence during measurement/reset, leakage, and crosstalk) and validate their models against detailed correlation diagnostics $p_{ij}$. The results illuminate the path toward scalable fault-tolerant quantum computing by quantifying the performance gains from larger codes and outlining practical requirements (e.g., reducing CZ and measurement-related errors, mitigating leakage) to achieve algorithmically-relevant, scalable logical error rates.

Abstract

Practical quantum computing will require error rates that are well below what is achievable with physical qubits. Quantum error correction offers a path to algorithmically-relevant error rates by encoding logical qubits within many physical qubits, where 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 in order for logical performance to improve with increasing code size. Here, we report the measurement of logical qubit performance scaling across multiple code sizes, and demonstrate that our system of superconducting qubits has sufficient performance to overcome the additional errors from increasing qubit number. We find our distance-5 surface code logical qubit modestly outperforms an ensemble of distance-3 logical qubits on average, both in terms of logical error probability over 25 cycles and logical error per cycle ($2.914\%\pm 0.016\%$ compared to $3.028\%\pm 0.023\%$). To investigate damaging, low-probability error sources, we run a distance-25 repetition code and observe a $1.7\times10^{-6}$ logical error per round floor set by a single high-energy event ($1.6\times10^{-7}$ when excluding this event). We are able to accurately model our experiment, and from this model we can extract error budgets that highlight the biggest challenges for future systems. These results mark the first experimental demonstration where quantum error correction begins to improve performance with increasing qubit number, illuminating the path to reaching the logical error rates required for computation.

Figures (36)

• Figure 1: Implementing surface code logical qubits.a, Schematic of a 72-qubit Sycamore device with a distance-5 surface code embedded, consisting of 25 data qubits (gold) and 24 measure qubits (blue). Each measure qubit is associated with a stabiliser (blue colored tile, dark: $X$, light: $Z$). Representative logical operators $Z_L$ (black) and $X_L$ (green) traverse the array, intersecting at the lower-left data qubit. The upper-right quadrant (red outline) is one of four subset distance-3 codes (the four quadrants) we compare to distance-5. b, Illustration of a stabiliser measurement, focusing on one data qubit (gold) and one measure qubit (blue), in perspective view with time progressing to the right. Each qubit participates in four controlled-Z (CZ) gates with its four nearest neighbours, interspersed with Hadamard gates (H), and finally, the measure qubit is measured and reset to $|0\rangle$. Data qubits perform dynamical decoupling (DD) while waiting for the measurement and reset. All stabilisers are measured in this manner concurrently. Cycle duration is 921 ns, including 500 ns measurement and 160 ns reset. c, Cumulative distributions of errors for single-qubit gates, CZ gates, measurement, and data qubit DD (idle during measurement and reset). Benchmarked in simultaneous operation using random circuit techniques, on the 49 qubits used in distance-5 and the four CZ layers from the stabiliser circuit emerson2005scalablearute2019quantum. Vertical lines are means.
• Figure 2: Error detection in the surface code.a, Illustration of a surface code experiment, in perspective view with time progressing to the right. We begin with an initial data qubit state which has known parities in one stabiliser basis (here, $Z$). We show example errors that manifest in detection pairs: a $Z$ error (red) on a data qubit (spacelike pair), a measurement error (purple) on a measure qubit (timelike pair), an $X$ error (blue) during the CZ gates (diagonal pair), and a measurement error (green) on a data qubit (detected in the final inferred $Z$ parities). b, Detection probability for each stabiliser over a 25-cycle distance-5 experiment (50,000 repetitions). Darker lines: average over all stabilisers with the same weight. There are fewer detections at $t=0$ because there is no preceding data idling, and at $t=25$ because the final parities are calculated from data qubit measurements. c, Detection probability heatmap, averaging over $t=1$ to 24. d-e, Similar to b-c for four separate distance-3 experiments covering the four quadrants of the distance-5 code. f-g, Similar to b-c using a simulation with Pauli errors plus leakage, crosstalk, and stray interactions (Pauli+). h, Bar chart summarising the detection correlation matrix $p_{ij}$, comparing the distance-5 experiment from b to the simulation in f (Pauli+) and a simpler simulation with only Pauli errors. We aggregate four groups of correlations: timelike pairs; spacelike pairs; diagonal pairs expected for Pauli noise; and diagonal pairs unexpected for Pauli noise ("Unexp."), including correlations over two timesteps. Each bar shows a mean and standard deviation of correlations from a 25-cycle, 50,000-repetition dataset.
• Figure 3: Logical error reduction.a, Logical error probability $p_L$ vs. cycle comparing distance-5 (blue) to distance-3 (pink: four separate quadrants, red: average), all averaged over $Z_L$ and $X_L$. Each individual datapoint represents 100,000 repetitions. Solid line: fit to experimental average, $t=3$ to 25 (see main text). Dotted line: comparison to Pauli+ simulation. b, Logical fidelity $F=1-2p_L$ vs. cycle, semilog plot. Same experimental averages and fits from a. c, Summary of experimental progression comparing logical error per round $\varepsilon_d$ (specifically plotting $1-\varepsilon_d$) between distance-3 and $5$, where system improvements lead to faster improvement for distance-5 (see main text). Each open circle is a comparison to a specific distance-3 code, and filled circles average over multiple distance-3 codes measured in the same session. Markers are colored chronologically from light to dark. Typical $1\sigma$ statistical and fit uncertainty is $0.02\%$, smaller than the points.
• Figure 4: Towards algorithmically-relevant error rates.a, Estimated error budgets for the surface code, based on operation errors (see Fig. 1c) and Pauli+ simulations. $\Lambda_{3/5} = \varepsilon_3/\varepsilon_5$. CZ: contributions from CZ error (excluding leakage and stray interactions). CZ stray int: CZ error from unwanted interactions. DD: dynamical decoupling, data qubit idle error during measurement and reset. Measure: measurement and reset error. Leakage: leakage during CZs and due to heating. 1Q: single-qubit gate error. b, Logical error for repetition codes. Inset: schematic of the distance-25 repetition code, using the same data and measure qubits as the distance-5 surface code. Smaller codes are subsampled from the same distance-25 data chen2021exponential. A high-energy event resulted in an apparent error floor around $10^{-6}$. After removing the instances nearby (light blue), error decreases more rapidly with code distance. 50 cycles, $5\times 10^5$ repetitions. We also plot the surface code error per cycle from Fig. 3b in black. c, Contour plot of simulated surface code logical error per round $\varepsilon_d$ as a function of code distance $d$ and a scale factor $s$ on the error model in Fig. 1c (Pauli simulation, $s=1.0$ corresponds to the current device error model). d, Horizontal slices from c, each for a value of error model scale factor $s$. $s=1.3$ is above threshold (larger codes are worse), while $s=1.2$ to $1.0$ represent the crossover regime, where progressively larger codes get better until a turnaround. $s=0.9$ is below threshold (larger codes are better).
• Figure S5: Qubit coordinates. Left: Distance-5 surface code as presented in the main text, with an $(x, y)$ coordinate system indicated. Right: Rotated coordinate system used for heatmap plots in the supplement, using (row, column).