_Pauli $+$_ model by doing a direct comparison with the equivalent kraus_sim
simulation. Specifically, we simulated the distance-3 $Z$-basis and $X$-basis
experiments associated with the West device configuration. Each 25-round
simulation corresponded to 200,000 samples. The classical _Pauli $+$_
simulation required about 160 seconds (distributed over 16 CPU cores), while
the quantum simulation required 11 hours333Note that the qsim backend for the
kraus_sim simulator has not been optimized for performance on these system
sizes.. Decoding was implemented using the algorithm in Ref. [63], with
detection cluster probabilities inferred from the $p_{ij}$ matrix.

As can be seen in Figures S19-S21, there is generally quite good agreement
between both simulations with respect to logical error and typical detection
event statistics. It is not entirely clear why this is the case. Generally,
the surface code measurement circuit implies a stabilizer-state projection at
the end of each cycle; this has the effect of "twirling" the quantum noise, so
that for a single data qubit error in the absence of leakage the approximation
is exact[99]. The same is true for errors in non-neighboring circuit
locations. With the net error rates $\sim 1\%$ per gate and total of $n\sim
20$ qubits, we expect around one error per cycle. Moreover, some of the
modeled error channels, (such as dephasing), are described by a Pauli channel
exactly.

On the other hand, our simulations also include some unitary rotation errors
(due to crosstalk) which may add coherently in a QMC simulation[100]. Early
work[101] simulating smaller distance codes suggested that Twirling
Approximation under both decoherence and unitary gate errors strongly over
predicted the expected logical error (by factors of 2 or more). Interestingly,
an early numerical test of the distance-3 surface code [73] found good
agreement with the Pauli Twirling Approximation under amplitude damping
($T_{1}$ decay) and (white noise) dephasing, but only in the logical $Z$ basis
(twirling over-predicted the error for the logical $X$). There are several
factors that may have contributed to reducing these effects in our
simulations. First, the Hadamard operations in our experiments are chosen so
that the stabilizer generators describing our system are all of mixed $ZXXZ$
type[45, 46]. This has the effect of approximately symmetrizing all bit-flip
and phase-flip errors. Second, we deliberately insert $X$ gates whenever a
qubit is idle, which is also known to reduce coherent errors. With these
measures in place, a good agreement between an exact QMC and a classical
simulations indicates that the net contribution of coherently-added errors is
not large enough to see.

Component | Error probability
---|---
SQ gates | $1.09\times 10^{-3}$
CZ gates | $6.05\times 10^{-3}$
Data qubit idle | $2.46\times 10^{-2}$
Reset | $1.86\times 10^{-3}$
Readout | $1.96\times 10^{-2}$
CZ leakage | $2.0\times 10^{-4}$
Leakage from heating | $6.4\times 10^{-4}$
CZ crosstalk | $9.5\times 10^{-4}$
Table 1: Average probabilities of main errors at the operation point of $d=5$
surface code experiments.

##  XV Sensitivity of logical error per cycle to physical errors

In this section we provide the sensitivity coefficients of surface code
logical error per cycle ($\varepsilon_{L}$) to errors in the main components
of the device; namely, control-Z (CZ) gates, single qubit (SQ) gates, data
qubit idle (this includes dynamical decoupling sequence during readout and
reset time), readout and reset. Additionally, we also present
$\varepsilon_{L}$ sensitivity coefficients to leakage and crosstalk. The
results are obtained using the Pauli+ simulator and the correlated minimum-
weight perfect matching decoder. We note that this analysis is separate from
the $1/\Lambda$ analysis presented in Fig. 4a of the main text. Specifically,
in Fig. 4a, we used the methodology of Ref. [42] to estimate the $1/\Lambda$
budget with sensitivities evaluated at the half-operation point (i.e.,
component errors being 0.5 times the component errors shown in Table 1, used
in the main simulation).

For a certain component error (e.g., SQ gate error), we evaluate the
sensitivity coefficient for the logical error per cycle $\varepsilon_{\rm L}$
using the formula

$\displaystyle\nu_{\rm error}=\frac{\delta\varepsilon_{\rm L}}{\delta p_{\rm
error}},$ (17)

where $\delta\varepsilon_{\rm L}$ is the change of the logical error per cycle
due to a variation $\delta p_{\rm error}$ of the error probability of all
components of the same type (e.g., when calculating the $\varepsilon_{\rm L}$
sensitivity to SQ gate errors, $\delta p_{\rm error}$ is the error change of
all SQ gates, excluding dynamical decoupling gates).

The logical error per cycle $\varepsilon_{\rm L}$ is a nonlinear function of
the component error probabilities, so the sensitivity coefficients depend on
the operation point (i.e., linearization point). We are particularly
interested in evaluating the $\varepsilon_{\rm L}$ sensitivities at the
experimental operation point, discussed below.

###  XV.1 Experimental operation point

The experimental operation point of the $d=5$ surface code experiment (used in
the simulator) is specified by the error probabilities of all components in
the surface code circuit. We independently measure the component error
probabilities to be used in the simulator. Table 1 shows Pauli error
probabilities averaged over all components of the same type, while individual
values for every circuit element are used in the simulator.

In particular, the SQ gate errors are measured by RB for each qubit and the CZ
gate errors are measured by XEB for each CZ. Data qubit idle errors are
measured individually by interleaved RB, which includes dynamical decoupling
sequence used during readout and reset. The readout and reset errors are also
measured independently.

Another imperfection present in our device is leakage into non-computational
states (mainly to state $|2\rangle$). We assume that leakage is generated at
the high frequency qubit of a CZ gate (e.g., due to qubit dephasing during CZ
operation) with a nominal probability of

$p_{2}^{\rm CZ}=0.25\,p_{t}=2.0\times 10^{-4},$ (18)

where we assume parameter $p_{t}=8\times 10^{-4}$ for all CZs (see Sec.
XIV.1.3) and the factor 0.25 is the probability of state $|11\rangle$ before a
CZ gate during surface code operation. Moreover, leakage can be generated from
a non-equilibrium “heating” process at each qubit, for which we use a
probability per QEC cycle of

$p_{2}^{\rm heating}=0.5\,\Gamma_{1\to 2}\,t_{\rm cycle}=6.4\times 10^{-4},$
(19)

where the factor 0.5 is the probability that the qubit is in state $|1\rangle$
during surface code operation, the QEC cycle duration is $t_{\rm cycle}=896$
ns, and we assume the experimentally estimated heating rate of $\Gamma_{1\to
2}=1/(700\,{\rm\mu s})$ being the same for all qubits. Note that in the
simulator the possibility of heating is considered after each gate or idling,
so the actual parameter is $\Gamma_{1\to 2}$, but we still characterize the
heating strength by $p_{2}^{\rm heating}$.

Finally, another imperfection in the device is the presence of unwanted
interactions (crosstalk) between simultaneous gates (either single qubit idle
or CZ), see Sec. XIV.1.4. This error channel is modelled individually for all
elements and leads to CZ errors with a Pauli error probability (averaged over
all CZs) of

$\displaystyle p_{\rm CZ}^{\rm crosstalk}=9.5\times 10^{-4},$ (20)

which is roughly 15% of the observed total CZ error. Note that in the
simulator this contribution is subtracted from the total CZ error to obtain
the depolarizing part of the CZ error.

Component | sensitivity (d3) | sensitivity (d5)
---|---|---
SQ gates | $6.2\pm 0.3$ | $8.4\pm 0.2$
CZ gates | $2.13\pm 0.08$ | $4.0\pm 0.2$
Data qubit idle | $0.91\pm 0.02$ | $1.05\pm 0.03$
Readout or reset | $0.26\pm 0.01$ | $0.41\pm 0.02$
Leakage (heating) | $2.4\pm 0.3$ | $4.0\pm 0.8$
CZ crosstalk | $5.0\pm 0.5$ | $6.5\pm 0.6$
Table 2: Logical error rate sensitivities at the experimental operation point.

###  XV.2 Logical error rate sensitivities for $d=3$, 5 surface codes

Table 2 shows the sensitivity coefficients of $d=3$ and $d=5$ logical error
per cycle to errors in the main components of the surface code circuit, and
also the sensitivities to leakage and crosstalk errors. The main takeaway from
this table is that $d=5$ surface code is more sensitive to component errors
than $d=3$ surface code.

We have computed these sensitivity coefficients at the experimental operation
point. For instance, for SQ gate errors, $\delta p_{\rm error}$ in Eq. (17) is
the variation of the SQ gate error probability $\delta p_{\rm sq}$, which is
assumed to be the same for all SQ gates (excluding those in dynamical
decoupling sequence). As shown by the orange markers in Figs. S22 and S23, the
dependence of the change of logical error per cycle $\delta\varepsilon_{\rm
L}$ on the variation of the SQ gate error $\delta p_{\rm sq}$ is fairly
linear. From a linear fit (orange dashed lines in Figs. S22 and S23) to the
simulation data we obtain the sensitivity coefficients for single qubit gate
errors: $\nu_{\rm sq}=6.2\pm 0.3$ ($d=3$) and $8.4\pm 0.2$ ($d=5$). A similar
procedure is used to obtain the $\varepsilon_{\rm L}$ sensitivity coefficients
for the component errors indicated in Table 2.

For leakage and crosstalk, there are subtleties in this procedure. For leakage
from heating, we actually vary the heating rate $\Gamma_{1\to 2}$ applied to
all qubits, while in Eq. (17) we use $\delta p_{\rm
error}=0.5\,\delta\Gamma_{1\to 2}\,t_{\rm cycle}$. For crosstalk, we scale all
crosstalk unitaries as $U_{I}\to U_{I}^{\alpha}$ (with the power $\alpha=1$
corresponding to the operation point) and use $\delta p_{\rm
error}=(\alpha^{2}-1)p_{\rm CZ}^{\rm crosstalk}$ in Eq. (17) with the nominal
crosstalk error value $p_{\rm CZ}^{\rm crosstalk}=9.5\times 10^{-4}$.

Figure S22: Calculation of logical error rate sensitivities for $d=3$ surface
code. The depicted logical error rates are averaged values over the four $d=3$
surface code grids. The variable $\delta p_{\rm error}$ is the variation of
the corresponding component error probability. Dashed lines are linear fits to
the simulation data (markers) and their slopes are the sensitivities reported
in Table 2.  Figure S23: Calculation of logical error rate sensitivities for
$d=5$ surface code. Similarly to Fig. S22, dashed lines are linear fits to the
simulation data (markers) and their slopes are the sensitivities reported in
Table 2.

Figure S24: Correlation matrix $p_{ij}$. Panel (a) illustrates the $600\times
600$ symmetric correlation matrix $p_{ij}$ for a 25 rounds $d=5$ surface code
experiment with data qubits prepared in the $Z$-basis. Each detection node
$i=(t,s)$ has time coordinate $t$ indicated by the minor ticks and a spatial
coordinate $s$ indicated by the measure qubit labels ($s=$ q2_5, q4_3, …
q9_6). Panel (b) illustrates the difference of the $p_{ij}$ correlation
matrices from experimental and simulation Pauli$+$ data. The ellipses indicate
the main discrepancies between the experiment and simulation, which are due to
excess leakage accumulation in a pair of data qubits (2_6 and 2_4) during the
surface code experiment.

##  XVI $p_{ij}$ diagnostics of surface codes

We analyze the pairwise detection event correlations in surface code data
using the $p_{ij}$ correlation matrix method that was introduced in Ref. [42].
This method quantifies the probability $p_{ij}$ of simultaneous triggering of
two detection events at the error detection nodes $i$ and $j$. The $p_{ij}$
method can provide the correlation probability for any pair $i$-$j$ (edge),
but we will focus here on the dominant pairwise correlations that we observe
in the data; namely, timelike, spacelike and spacetimelike (referred to as
diagonal in the main text) pairs. Hereon, we will refer to pairs as edges. We
also compare the experiment vs. Pauli$+$ simulation $p_{ij}$ correlation
matrices. The experimental data that is used to compare against simulations is
from the 25 rounds, $d=5$ surface code experiment with data qubits prepared in
the Z basis.

###  XVI.1 Experiment vs. Pauli$+$ correlation matrices $p_{ij}$

Panel (a) of Fig. S24 is a graphical representation of the $600\times 600$
symmetric correlation matrix $p_{ij}$ for the considered $d=5$ surface code
experiment with 25 QEC rounds and initial data qubit states prepared in the
$Z$-basis. The number of detection nodes $i$ is $12\times 26+12\times 24=600$,
since for the twelve measure qubits that measure the $Z$ stabilisers, we have
26 detection rounds (an additional detection round comes from the final data
qubit measurements), while for the remaining twelve measure qubits that
measure the X stabilisers, we have 24 detection rounds (two detection rounds
less since the values of the X-stabilisers are fully random at the start and
there is no $X$-measurement at the end of the Z-basis surface code
experiment). The detection nodes $i=(t,s)$ have a time coordinate $t$
(spanning from $t=0$ to 25 for the considered experiment) as well as a space
coordinate $s$ associated to the measure qubits. In Fig. S24(a), the time
coordinates are indicated by the minor ticks and the space coordinates are
indicated by the qubit labels such as $s={\rm q}2\\_5({\rm Z})$ for the
measure qubit 2_5 that measures a Z stabiliser. Note that even though we
actually use the $ZXXZ$ variant of the surface code, all notations for
stabilizers here are as if we were using the traditional surface code.

There are two distinct types of features in the $p_{ij}$ correlation matrix
illustrated in Fig. S24(a). Namely, we see some narrow reddish features (e.g.,
the one inside the qubit-qubit block q8_5-q6_5) that can be explained in terms
of conventional Pauli errors in the surface code circuit (such conventional
errors manifest in the $p_{ij}$ matrix as one-pixel-wide reddish features
since these errors produce detection events separated in time by 0 or 1
round). In addition, we also see some broader reddish features (e.g., the one
inside the qubit-qubit block q1_4-q2_5) that indicate the presence of long-
lived time correlations in the error detection events. Such correlations are
due to leakage accumulation in the data qubits, see Ref [42].

Panel (b) of Fig. S24 shows the difference between the $p_{ij}$ correlation
matrices from experimental data and Pauli$+$ simulation data (used in the main
text). We see that the $p_{ij}$ matrix difference looks much cleaner (with
fainter reddish regions than the experimental $p_{ij}$ matrix shown in Fig.
S24(a)). This indicates that Pauli$+$ simulation does a good job in capturing
most of the detection event correlations that are present in the experiment.
There are, however, some spatial/temporal correlations that are significantly
stronger in the experiment than in the simulation, indicated by the ellipses
in the $p_{ij}$ matrix difference. We attribute these features to stronger-
than-usual leakage in two data qubits: 2_4 and 2_6. Leakage accumulation in
these data qubits leads to detection events that are correlated locally in
space (with detection events at measure qubits that are neighbors to the leaky
data qubits 2_4 and 2_6) and correlated nonlocally in time (with a correlation
time of roughly $T_{1}/2\approx 10\,\mu$s). These correlations produce the
reddish regions indicated by the magenta and blue ellipses for leakage
accumulation in the data qubits 2_4 and 2_6, respectively. We stress that
Pauli$+$ simulation can in principle capture these missing correlations by
properly adjusting the simulation parameters related to leakage generation in
the data qubits 2_4 and 2_6 (e.g., by increasing the heating rates
$\Gamma_{1\to 2}$ or by increasing the leakage generation probabilities
$p_{2}^{\rm CZ}$ of the CZs that act on these leaky data qubits). Besides the
broad reddish regions indicated by the ellipses in Fig. S24(b), we also notice
some faint narrow reddish features in the $p_{ij}$ matrix difference. These
features indicate short temporal correlations of detection events separated in
time by 0 or 1 round, and they can be understood as a discrepancy between the
actual component error probabilities during the surface code experiment and
the component error probabilities assumed in the simulation. To quantify the
discrepancy between the component error probabilities, we need to compare the
$p_{ij}$ probabilities for the edges of the surface code error graph, which we
discuss below.

Figure S25: Main pairwise detection event correlations in the surface code.
The red dots indicate detection events. The considered pairwise correlations
(edges) are timelike (T) edges, spacelike (S) and spacetimelike (ST) edges.
These correlations are mainly from readout/reset errors, idle data qubit
errors and CZ errors, respectively.

###  XVI.2 $p_{ij}$ probability of main error edges in the surface code

In this section we examine the probabilities of the main pairwise correlations
(error edges) in the $d=5$ surface code. These error edges are depicted in
Fig. S25. Timelike edges (T-edges) indicate correlations of detection events
occurring at the same measure qubit and separated in time by 1 round. Physical
errors that give rise to T-edges mainly include readout/reset errors.
Spacelike edges (S-edges) indicate correlations of detection events occurring
at the same round and at two measure qubits of the same type (X or Z).
Physical errors that give rise to spacelike edges mainly include bit-flip
errors (from $T_{1}$ qubit decay) and phase-flip errors (from qubit dephasing)
at the data qubits during measurement and reset time (idle time). Finally,
spacetimelike edges indicate correlations of detection events separated in
time by 1 round and occurring at different measure qubits. Spacetimelike edges
that come from Pauli CZ errors are denoted as ST edges, while other
spacetimelike edges that are not expected from CZ errors are denoted as ST’
edges. The latter can be due to leakage or crosstalk.

####  XVI.2.1 Timelike edges

The probability of T-edges are obtained from the $p_{ij}$ correlation matrix
with $i=(t,s)$ and $j=(t+1,s)$, where the space coordinate $s$ refers to one
of the measure qubits. It is convenient to average over time $t$ and present
the time-averaged T-edge probabilities as shown at the top panel heatmap of
Fig. S26. This way of presenting the $p_{ij}$ data for the T-edges is
particularly useful to spot the measure qubits with good or bad readout/reset
errors. We point out that, although readout/reset errors are the main
contributors to the T-edges in our experiment, other physical errors (e.g.,
leakage and CZ errors) can also contribute to the T-edge probabilities.

The mean T-edge probability (averaging over all qubits and all rounds) is

$\displaystyle p_{ij}^{{\rm T}-{\rm edge},\,{\rm mean}}=3.85\times
10^{-2}\;[{\rm Pauli\\!\\!+\,sim}=$ $\displaystyle\;3.7\times 10^{-2},$
$\displaystyle{\rm Pauli\;sim}=$ $\displaystyle\;3.0\times 10^{-2}],$

where we have also included the averaged T-edge probabilities from Pauli$+$
and Pauli simulations.

Figure S26: Top panel: timelike edge probabilities. Each number in the
heatmaps is the median of the T-edge probabilities of a measure qubit. Measure
qubits that measure X or Z stabilisers are indicated by X or Z. Top panel
shows the time-averaged T-edge probabilities for the 25 rounds $d=5$ surface
code experiment with data qubits initialized in the Z-basis. Bottom panel
shows the difference of T-edge probabilities between experiment and Pauli$+$
simulation.

The lower panel heatmap of Fig. S26 shows the difference of the time-averaged
T-edge probabilities between experiment and Pauli$+$ simulation. We see that
the difference is relatively small, indicating a good agreement between
experiment and simulation. The biggest discrepancy between experiment and
simulation is for T-edges of the measure qubits 1_4, 3_4, 2_5, 2_9, which are
spatially close to the data qubits 2_4 and 2_6 that exhibit more leakage in
the experiment than in the Pauli$+$ simulation. Thus the reason for this
discrepancy is most likely leakage accumulation in these data qubits.

####  XVI.2.2 Spacelike edges

The heatmap at the top panel of Fig. S27 shows the time-averaged probabilities
of SX edges (spacelike edges between two X measure qubits) for the $d=5$
surface code experiment in the Z-basis. To explain the information displayed
in this heatmap, let us consider the middle data qubit 5_5. A phase-flip error
in this data qubit during idle time produces two detection events at the
neighboring X measure qubits 5_4 and 5_6 (see horizontal red edge in Fig. S27)
and at some round $t$. The number 0.043 written in the middle tile (5,5) is
the average (specifically, the median) of the $p_{ij}$ probabilities of all SX
edges between these two X measure qubits. Idle Y errors in the data qubit 5_5
also contributes to the displayed probability 0.043; for this reason, we write
’T2’ below 0.043 to remind us that this SX edge probability comes from phase-
flip or Y idle data qubit errors (in reality, other errors such as leakage and
CZ errors can also contribute to the SX edge probabilities). Let us consider
another example: an idle bit-flip error (due to T1 qubit decay) in the data
qubit 6_4 produces a SX edge between the X measure qubits 5_4 and 7_4
(vertical red edge in Fig. S27). One might expect that all SX edges are
produced by phase-flip idle data qubit errors. This is not the case for our
surface code experiments since we implement the ZXXZ variant of the surface
code circuit (see main text).
Idle errors in the boundary data qubits of the surface code grid sometimes
produce just one detection event (i.e., a boundary edge). For instance, this
is the case of an idle phase-flip error in the data qubit 1_5 that produces
only one detection event at the X measure qubit 1_4 and at some time $t$.
Finally, we also have the situation where idle errors in two different
boundary data qubits produce the same detection event or boundary edge. For
instance, a bit-flip error in data qubit 6_2 and a phase-flip error in data
qubit 5_1 both produce the same boundary edge at the X measure qubit 5_2. In
this ambiguous situation, we split equally the $p_{ij}$ probability of the
boundary edge among these data qubits [in this example 0.03 in the tiles (5,1)
and (6,2)] and write asterisks at the corresponding data qubit tiles.

Figure S27: Top panel: time-averaged $p_{ij}$ probabilities of SX edges. Pink
tiles with an X indicate the measure qubits that measure X stabilisers and the
empty pink tiles indicate the other (Z) measure qubits. The red horizontal
edge indicates SX edges between the X measure qubits 5_4 and 5_6. The
probabilities of these SX edges are obtained from the $p_{ij}$ matrix with
$i=(s,t)$ and $j=(s^{\prime},t)$, and $s={\rm q}5\\_4$ and $s^{\prime}={\rm
q}5\\_6$. After averaging over time $t$, we write the result in the middle
data qubit tile (5,5) since phase-flip errors in this data qubit would produce
such SX edges. Asterisks indicate ambiguous data qubits (e.g., the pair 5_1
and 6_2) in the sense that idle errors at those data qubits produce the same
boundary edge (see Sec. XVI.2.2). Lower panel shows the difference of the
time-averaged SX edge probabilities between experiment and Pauli$+$
simulation. Labels T1 and T2 at the tiles indicate the type of idle data qubit
error (bit-flip and phase-flip errors, respectively) that gives rise to the SX
edges (see Sec. XVI.2.2).

Figure S28: Top panel: time-averaged $p_{ij}$ probabilities of SZ edges.
Description of the information displayed at the top panel is similar to that
of Fig. S27. Lower panel shows the difference of the time-averaged SZ edge
probabilities between experiment and Pauli$+$ simulation.

Figure S28 is complementary to Fig. S27, and it displays the time-averaged SZ
edge probabilities. For instance, for the middle data qubit 5_5, we read a SX
edge probability of 0.043 from Fig. S27, and a SZ edge probability of 0.031
from Fig. S28. The bottom panels of Figs. S27 and S28 show the difference
between the experimental and simulated values, which is relatively small.

The mean spacelike edge probabilities are

$\displaystyle p_{ij}^{{\rm SX}-{\rm edge},\,{\rm mean}}=3.4\times 10^{-2}\;[$
$\displaystyle{\rm Pauli\\!\\!+sim}=3.3\times 10^{-2},$ $\displaystyle{\rm
Pauli\;sim}=3.1\times 10^{-2}],$

and

$\displaystyle p_{ij}^{{\rm SZ}-{\rm edge},\,{\rm mean}}=3.2\times 10^{-2}\;[$
$\displaystyle{\rm Pauli\\!\\!+sim}=3.0\times 10^{-2}$ $\displaystyle{\rm
Pauli\;sim}=2.9\times 10^{-2}],$

where we have also included the results from Pauli$+$ and Pauli simulations.

Figure S29: Time-averaged $p_{ij}$ probabilities of ST-edges. At the top
panel, each number is the time average of ST edges from $i=(t,s_{i})$ [$s_{i}$
are the qubit labels indicated at the x-axis] to $j=(t+1,s_{j})$ [$s_{j}$ are
the qubit labels indicated at the y-axis]. In this figure we only include
pairwise correlations $i$-$j$ that are expected from CZ errors. At the lower
panel, we show the difference of the time-averaged ST-edges between experiment
and Pauli$+$ simulation. At the lower panel, numbers that are smaller in
magnitude than $2.5\times 10^{-3}$ are not shown.

Figure S30: Time-averaged $p_{ij}$ probabilities of spacetimelike edges not
expected from CZ errors (ST’ edges). These unexpected pairwise correlations
are mainly from leakage in data qubits. Top panel shows the ST’-edge
probabilities from the $d=5$ surface code experiment, and the lower panel
shows the discrepancy between experiment and Pauli$+$ simulation. Numbers that
are smaller in magnitude than $2.5\times 10^{-3}$ are not shown.

####  XVI.2.3 Spacetimelike edges

Within the conventional Pauli error model, spacetimelike edges are due to CZ
Pauli errors. Those spacetimelike edges are referred to as ST-edges. In the
experiment and in the Pauli$+$ simulations, we also find other unexpected
spacetimelike edges that we denote as ST’ edges, which are mainly due to
leakage accumulation in the data qubits. We expect that leakage in the data
qubits should increase the ST- and ST’-edges by roughly the same amount, and
this is indeed validated by the experimental and simulation data, as shown
below.

Top panel of Fig. S29 shows the time-averaged ST-edge probabilities for all ST
edges (expected due to CZ errors) for experimental data. The lower panel shows
the discrepancy between experiment and Pauli$+$ simulation.

The mean ST-edge probability for the $d=5$ surface code experiment is

$\displaystyle p_{ij}^{{\rm ST}-{\rm edge},\,{\rm mean}}=1.3\times
10^{-2}\;[{\rm Pauli\\!\\!+sim}=$ $\displaystyle\;1.1\times 10^{-2},$
$\displaystyle{\rm Pauli\;sim}=$ $\displaystyle\;0.8\times 10^{-2}].$

We see that the ST-edge probability that is expected from the conventional
Pauli error model is $0.8\times 10^{-2}$; however, the actual ST-edge
probability is higher by $0.5\times 10^{-2}$ in the experiment and by
$0.3\times 10^{-2}$ in the Pauli$+$ simulation. This excess of ST-edge
probability turns out to be similar to the average probability of the
unexpected ST’-edges:

$\displaystyle p_{ij}^{{\rm ST^{\prime}}-{\rm edge},\,{\rm mean}}=0.6\times
10^{-2}\;[$ $\displaystyle{\rm Pauli\\!\\!+sim}=0.35\times 10^{-2}].$

A significant difference here indicates that we most likely underestimate
leakage in the simulation.

The time-averaged probability of all ST’ edges for the experimental data is
shown at the top panel of Fig. S30, and the lower panel shows the discrepancy
between experiment and simulation. We notice that the largest discrepancies
are present in ST’-edges between measure qubits that are spatially close to
the data qubits 2_4 and 2_6 which exhibit more leakage accumulation in the
experiment than in the simulation, see lower panel of Fig. S24.

###  XVI.3 Probability of clusters of detection events using generalized
$p_{ij}$

In the surface code, there are physical errors (e.g., Y errors in the data
qubits during measurement and reset time) that can produce more than two
detection events. To characterize such physical processes using experimental
error detection data, we use a generalized version of the $p_{ij}$ correlation
matrix method [42] that allows us to calculate the probability of clusters of
detection events. To be specific, let us assume that we are interested in
finding out the probability $p_{123}$ of a physical process that can
simultaneously flip the state $x_{i}$ ($x_{i}=1$ if there is an error
detection event, otherwise $x_{i}=0$) of three error detection nodes
$i=1,2,3$. To do this, we describe the statistics of the error detection
events at these three nodes in terms of seven independent physical processes:
three 1-body processes that separately flip the state of the nodes $i$ with
probabilities $p_{i}$; three 2-body processes where each of them
simultaneously flips the states of two nodes $i,j$ with probabilities
$p_{ij}$, and one 3-body process that simultaneously flips the states of the
three considered nodes with the sought probability $p_{123}$. The idea to find
$p_{123}$ is to express the following seven experimental averages: $\langle
x_{1}\rangle$, $\langle x_{2}\rangle$, $\langle x_{3}\rangle$, $\langle
x_{1}x_{2}\rangle$, $\langle x_{1}x_{3}\rangle$, $\langle x_{2}x_{3}\rangle$
and $\langle x_{1}x_{2}x_{3}\rangle$ in terms of the probabilities of the
seven processes $p_{1}$, $p_{2}$, $p_{3}$, $p_{12}$, $p_{23}$, $p_{13}$ and
$p_{123}$. Then solving numerically this nonlinear systems of seven equations
with seven unknowns, we obtain the sought probability $p_{123}$. This
generalized $p_{ij}$ method can be applied to analyze processes that can
produce arbitrary number $n$ of detection events; in this case, we would need
to solve $2^{n}-1$ nonlinear equations with the same number of unknown
probabilities (one of which is the probability of the $n$-body process we are
interested to find).

We have used the generalized $p_{ij}$ method to do error diagnostics of higher
order processes (e.g., Y data qubit errors) using the experimental error
detection data. We also use the cluster probabilities provided by the
generalized $p_{ij}$ method to set the weights of decoders, discussed in
Section XII.

Component | $p_{\rm expt}^{(i)}$ | $w_{i}$ |  $1/\Lambda$ contrib.
---|---|---|---
SQ gates | $1.09\\!\times\\!10^{-3}$ | 78.7 | 0.086 (9.6%)
CZ gates | $4.85\\!\times\\!10^{-3}$ | 54.5 | 0.264 (29.4%)
Data qubit idle | $2.46\\!\times\\!10^{-2}$ | 7.0 | 0.172 (19.2%)
Readout | $1.96\\!\times\\!10^{-2}$ | 5.6 | 0.11 (12.2%)
Reset | $1.86\\!\times\\!10^{-3}$ | 5.6 | 0.0104 (1.2%)
Leakage (heating) | $6.4\\!\times\\!10^{-4}$ | 125 | 0.08 (8.9%)
CZ leakage | $2.0\\!\times\\!10^{-4}$ | 125* | 0.025 (2.8%)
CZ crosstalk | $9.5\\!\times\\!10^{-4}$ | 158 | 0.15 (16.7%)
Table 3: Calculation of the error budget for $1/\Lambda_{3/5}$. We multiply
the component errors $p_{\rm expt}^{(i)}$ by the sensitivities (weights)
$w_{i}$ at the half-operation point, resulting in the contributions to
$1/\Lambda_{3/5}$ shown in the right column.

##  XVII Surface code $1/\Lambda$ error budget

In this section we discuss the procedure to obtain the surface code error
budget for $1/\Lambda_{3/5}$, which is presented as the bar chart in Fig. 4a
of the main text. Following Ref. [42], we write $1/\Lambda_{3/5}$ as a sum of
contributions from each error channel $i$ that is considered in the Pauli+
simulation,

$\displaystyle(\Lambda_{3/5})^{-1}=\sum_{i}w_{i}\,p_{\rm expt}^{(i)}=w\,p_{\rm
expt},$ (21)

where $p_{\rm expt}$ is the vector of component error probabilities at the
experimental operation point and $w$ is the vector of weights. The latter is
obtained from the gradient (sensitivities) of the nonlinear function
$[1/\Lambda_{3/5}](p)$ at half experimental operation point (i.e., at
$p=p_{\rm expt}/2$), which for simplicity is referred to as "half-operation
point".

The half-operation point is defined as half of the experimentally measured
component error probabilities for SQ gates, CZ gates, data qubit idle, reset
and readout – see Table 1. Additionally, the simulation leakage parameters
become $1/(1.4\,{\rm ms})$ for the heating rate and $1.0\times 10^{-4}$ for
the probability of leakage generation from qubit dephasing during CZs (CZ
leakage), and the crosstalk unitaries are rescaled from $U_{I}$ to
$(U_{I})^{1/\sqrt{2}}$ at half-operation point.

The third column in Table 3 shows the sensitivities of $1/\Lambda_{3/5}$ at
half-operation point for the eight error channels that are considered in the
simulations. These sensitivities are then used as the weight parameters
$w_{i}$ in Eq. (21) to obtain the contribution of each error channel to
$1/\Lambda_{3/5}$. The resulting contributions are shown in the right column
of Table 3. Note that for the CZ error channel, we use error probability
$4.85\times 10^{-3}$ instead of $6.05\times 10^{-3}$ in Table 1 to avoid
double count of the CZ error coming from crosstalk and CZ leakage: we subtract
the contribution of $9.5\times 10^{-4}$ from crosstalk and the contribution of
$1.25\times 2\times 10^{-4}$ from CZ leakage. Also note that for the
sensitivity to CZ leakage we use the same value as for the sensitivity to the
leakage from heating.

The values from the right column of Table 3 are used in Fig. 4a of the main
text. The sum of these values is $0.90$, which is very close to the inverse of
the simulated value $\Lambda_{3/5}=1.10$.

##  XVIII Overview of error correction experiments

Table 4: Summary of various error correction and error detection experiments.
Experiments using “classical" codes (i.e. codes that only detect one type of
error e.g. only phase flips or only bit flips) use $[n,k,d]$ code notation
instead of quantum $[[n,k,d]]$ code notation. Entries with an N/A are
experiments related to embedding error correction into the physical qubits as
opposed to layering the error correction on top of the physical qubits.

Paper | Year | Code name | [[#data,#logical,distance]] | Physical qubits | Rounds | Physical qubit type
---|---|---|---|---|---|---
[102] | 1998 | Repetition Code | [3,1,3] | 3 | single shot | NMR
[103] | 2001 | Perfect Code | [[5,1,3]] | 5 | single shot | NMR
[104] | 2011 | Repetition Code | [3,1,3] | 3 | 3 | Ion trap
[105] | 2011 | Repetition Code | [3,1,3] | 3 | 2 | NMR
[106] | 2011 | Repetition Code | [3,1,3] | 3 | single shot | NMR
[107] | 2012 | Repetition Code | [3,1,3] | 3 | single shot | Superconducting
[108] | 2012 | Perfect Code | [[5,1,3]] | 5 | single shot | NMR
[109] | 2014 | Surface Code | [[4,1,2]] | 4 | single shot | Photons
[61] | 2014 | Repetition Code | [3,1,3]-[5,1,5] | 9 | 8 | Superconducting
[110] | 2014 | Color Code | [[7,1,3]] | 7 | single shot | Ion trap
[111] | 2014 | Repetition Code | [[3,1,3]] | 4 | single shot | NV center
[112] | 2015 | Repetition Code | [3,1,3] | 5 | single shot | Superconducting
[113] | 2015 | Bell State | [[2,0,2]] | 4 | single shot | Superconducting
[114] | 2016 | Repetition Code | [3,1,3] | 4 | 1-3 | Superconducting
[27] | 2016 | Cat States | N/A | 1 | 1-6 | 3D cavity
[115] | 2017 | Color Code | [[4,2,2]] | 5 | single shot | Superconducting
[116] | 2017 | Color Code | [[4,2,2]] | 5 | single shot | Ion trap
[117] | 2018 | Repetition Code | [3,1,3]-[8,1,8] | 15 | single shot | Superconducting
[118] | 2019 | Bell State | [[2,0,2]] | 3 | 1-12 | Superconducting
[119] | 2019 | Perfect Code | [[5,1,3]] | 5 | single shot | Superconducting
[120] | 2019 | Binomial Bosonic States | N/A | 1 | 1-19 | 3D cavity
[121] | 2020 | Repetition Code | [3,1,3]-[22,1,22] | 5-43 | single shot | Superconducting
[122] | 2020 | Surface Code | [[4,1,2]] | 7 | 1-11 | Superconducting
[123] | 2020 | Bell State | [[2,0,2]] | 3 | 1-26 | Superconducting
[21] | 2020 | Bacon-Shor Code | [[9,1,3]] | 15 | single shot | Ion trap
[124] | 2020 | Bacon-Shor Code | [[9,1,3]] | 11 | single shot | Photons
[29] | 2020 | GKP States | N/A | 1 | 1-200 | 3D cavity
[42] | 2020 | Repetition Code | [3,1,3]-[11,1,11], [[4,1,2]] | 5-21 | 1-50 | Superconducting
[20] | 2021 | Color Code | [[7,1,3]] | 10 | 2-12 | Ion trap
[24] | 2021 | Surface Code | [[9,1,3]] | 17 | 1-11 | Superconducting
[25] | 2022 | Perfect Code | [[5,1,3]] | 7 | 1-11 | NV center
[22] | 2022 | Surface Code | [[9,1,3]] | 17 | 1-16 | Superconducting
[125] | 2022 | Surface Code | [[4,1,2]] | 7 | 1-15 | Superconducting
[23] | 2022 | Subsystem Code | [[9,1,3]] | 23 | 1-10 | Superconducting
[126] | 2022 | Surface Code | [[13, 1, 3]] | 19 | 1 | Rydberg
[126] | 2022 | Toric Code | [[16, 2, 2]] | 24 | 1 | Rydberg
This work | 2022 | Repetition Code | [3,1,3]-[25,1,25] | 5-49 | 50 | Superconducting
This work | 2022 | Surface Code | [[9,1,3]]-[[25,1,5]] | 17-49 | 1-25 | Superconducting

##  XIX Additional plots of surface code data

Figure S31: Detection probabilities for individual codes. Figure S32: Logical
error probabilities vs quantum error correction cycle for the distance-5 code
for four scenarios, from left to right: experimental data with belief
matching, experimental data with tensor network decoding, Pauli$+$ simulation
with belief matching, and Pauli$+$ with tensor network decoding. Top row:
logical errors plotted on normal scale. Bottom row: logical fidelities plotted
on logscale. Figure S33: Logical error probabilities vs quantum error
correction cycle for the top left distance-3 code for four scenarios, from
left to right: experimental data with belief matching, experimental data with
tensor network decoding, Pauli$+$ simulation with belief matching, and
Pauli$+$ with tensor network decoding. Top row: logical errors plotted on
normal scale. Bottom row: logical fidelities plotted on logscale. Figure S34:
Logical error probabilities vs quantum error correction cycle for the top
right distance-3 code for four scenarios, from left to right: experimental
data with belief matching, experimental data with tensor network decoding,
Pauli$+$ simulation with belief matching, and Pauli$+$ with tensor network
decoding. Top row: logical errors plotted on normal scale. Bottom row: logical
fidelities plotted on logscale. Figure S35: Logical error probabilities vs
quantum error correction cycle for the bottom left distance-3 code for four
scenarios, from left to right: experimental data with belief matching,
experimental data with tensor network decoding, Pauli$+$ simulation with
belief matching, and Pauli$+$ with tensor network decoding. Top row: logical
errors plotted on normal scale. Bottom row: logical fidelities plotted on
logscale. Figure S36: Logical error probabilities vs quantum error correction
cycle for the bottom right distance-3 code for four scenarios, from left to
right: experimental data with belief matching, experimental data with tensor
network decoding, Pauli$+$ simulation with belief matching, and Pauli$+$ with
tensor network decoding. Top row: logical errors plotted on normal scale.
Bottom row: logical fidelities plotted on logscale.