Fault-tolerant thresholds for the surface code in excess of 5% under biased noise

TL;DR

This paper presents a high-threshold decoder for the surface code tailored to biased noise, achieving fault-tolerance thresholds over 5%, significantly improving quantum error correction under realistic noise conditions.

Contribution

Introduction of an efficient, bias-aware surface code decoder that exploits syndrome symmetries and extends to fault-tolerant regimes with measurement errors.

Findings

Fault-tolerance threshold exceeds 6% under biased noise.

Threshold remains above 5% with realistic noise bias levels.

Decoder exploits noise symmetries for improved performance.

Abstract

Noise in quantum computing is countered with quantum error correction. Achieving optimal performance will require tailoring codes and decoding algorithms to account for features of realistic noise, such as the common situation where the noise is biased towards dephasing. Here we introduce an efficient high-threshold decoder for a noise-tailored surface code based on minimum-weight perfect matching. The decoder exploits the symmetries of its syndrome under the action of biased noise and generalises to the fault-tolerant regime where measurements are unreliable. Using this decoder, we obtain fault-tolerant thresholds in excess of $6\%$ for a phenomenological noise model in the limit where dephasing dominates. These gains persist even for modest noise biases: we find a threshold of $\sim 5\%$ in an experimentally relevant regime where dephasing errors occur at a rate one hundred times greater than bit-flip errors.

Equations

$$\mathrm{Pr}(E)=(1-p{)}^{N-H-L}{p}_{\text{h.r.}}^H{p}_{\text{l.r.}}^L(1-q{)}^{M-Q}{q}^Q$$

$$\log \mathrm{Pr}(E)=H\log \frac{p_{\text{h.r.}}}{1-p}+L\log \frac{p_{\text{l.r.}}}{1-p}+Q\log \frac{q}{1-q}+k,$$

$${\mu }_t$$

$${\mu }_p$$

$${\mu }_d$$

Full text

The surface code Kitaev (2003); Dennis et al. (2002) is among the most promising quantum error-correcting codes to realize the first generation of scalable quantum computers Terhal (2015); Brown et al. (2016); Campbell et al. (2017). This is due to its two-dimensional layout and low-weight stabilizers that help give it its high threshold Dennis et al. (2002); Wang et al. (2003); Raussendorf and Harrington (2007), and its universal set of fault-tolerant logical gates Dennis et al. (2002); Bravyi and Kitaev (2005); Horsman et al. (2012); Brown et al. (2017); Brown (2019). Ongoing experimental work Barends et al. (2014); Córcoles et al. (2015); Kelly et al. (2015); Takita et al. (2016) is steadily improving the surface code error rates. Concurrent work on improved decoding algorithms Wang et al. (2003); Raussendorf and Harrington (2007); Duclos-Cianci and Poulin (2010); Fowler et al. (2012a); Bravyi et al. (2014); Darmawan and Poulin (2018) is leading to higher thresholds and lower logical failure rates, reducing the exquisite control demanded of experimentalists to realize such a system.

Identifying the best decoder for the surface code depends critically on the noise model. Minimum-weight perfect matching (MWPM) Edmonds (1965); Kolmogorov (2009) is near optimal in the case of the standard surface code with a bit-flip error model Dennis et al. (2002) and for a phenomenological error model with unreliable measurements Wang et al. (2003); see Ohno et al. (2004); Kubica et al. (2018). More recently, attention has turned to tailoring the decoder to perform under more realistic types of noise, such as depolarizing noise Duclos-Cianci and Poulin (2010); Wootton and Loss (2012); Fowler (2013); Bravyi et al. (2014); Darmawan and Poulin (2018) and correlated errors Hutter and Loss (2014); Nickerson and Brown (2019); Fowler et al. (2012b). Of particular note is noise that is biased towards dephasing: a common feature of many architectures. With biased noise and reliable measurements, it is known that the surface code can be tailored to accentuate commonly occurring errors such that an appropriate decoder will give substantially increased thresholds Tuckett et al. (2018a, b). However, these high thresholds were obtained using decoders with no known efficient implementation in the realistic setting where measurements are unreliable and the noise bias is finite.

In this Letter we propose a practical and efficient decoder that performs well for both finite bias and noisy measurements, demonstrating that the exceptional gains of the tailored surface code under biased noise extend to the fault-tolerant regime. We use the MWPM algorithm together with a recent technique to exploit symmetries of a given quantum error-correcting code Brown and Williamson (2020). Rather than using the symmetries of the code, we generalize this idea and use the symmetries of the entire system. Specifically, we exploit the symmetries of the syndrome with respect to its incident error model. Applied to pure dephasing noise, our decoder exploits the one-dimensional symmetries of the system by pairing the defects of each symmetry separately. Crucially, our approach readily extends to the situation where measurements are unreliable, as well as the finite-bias regime where some low-rate errors violate the symmetries we rely on. We demonstrate that our approach leads to fault-tolerant thresholds exceeding $6\%$ for infinite bias, with these substantial gains persisting to modest biases. Comparing with the optimal threshold of $3.3\%$ Ohno et al. (2004); Kubica et al. (2018) for conventional decoders that correct the bit-flip and dephasing errors of the same noise model separately, our results represent a very significant improvement in the level of noise that can be tolerated in practical quantum technologies.

Surface code tailored for dephasing.

We define the surface code in a rotated basis with $X$- and $Y$-type stabilizers, $S_{v}\in\mathcal{S}$, to provide additional syndrome information about $Z$ errors; see Fig. 1 and its corresponding caption. We consider errors $E\in\mathcal{E}$ drawn from a subgroup of the Pauli group $\mathcal{E}\subseteq\mathcal{P}$. We define the syndrome as a list of the locations of defects. For a given error, defects lie on vertices $v$ such that $S_{v}E|\psi\rangle=(-1)E|\psi\rangle$ for code states $|\psi\rangle$ satisfying $S_{v}|\psi\rangle=|\psi\rangle$ for all $v$.

Decoding with symmetry.

We first consider the infinite bias (pure-dephasing) error model generated by only $Z$ errors, $\mathcal{E}^{Z}=\left\langle Z_{f}\right\rangle$. Errors drawn from this model respect one-dimensional symmetries of the lattice, as in Fig. 1. A single $Z$ error generates two defects on each of its adjacent rows and columns. Up to boundary conditions, any error drawn from $\mathcal{E}^{Z}$ will respect a defect parity conservation symmetry on each of the rows and columns of the lattice.

Let us make this notion of a symmetry rigorous. A symmetry is specified by a subgroup of the stabilizer group $\mathcal{S}_{\text{sym}}\subseteq\mathcal{S}$. Elements $S\in\mathcal{S}_{\text{sym}}$ are defined with respect to an error model $\mathcal{E}$ such that they satisfy $SE|\psi\rangle=(+1)E|\psi\rangle$ for all $E\in\mathcal{E}$ and code states $|\psi\rangle$. This generalizes Ref. Brown and Williamson (2020) where symmetries are defined for the special case where $\mathcal{E}=\mathcal{P}$; the symmetry is now a function of the combined system of both the code and the error model.

For general Pauli error models, the surface code has global symmetries Kitaev (2003); $\prod_{v\in\mathcal{G}}S_{v}=1$ with $\mathcal{G}$ the set of either black or white vertices where we briefly assume periodic boundary conditions to illustrate this point. Under pure dephasing noise, the same model has a much richer set of one-dimensional symmetries. Observe that $S_{\mathcal{L}}=\prod_{v\in\mathcal{L}}S_{v}$, with $\mathcal{L}$ the set of vertices on a row or column, is a product of Pauli $Z$ matrices. As such, the one-dimensional stabilizers $S_{\mathcal{L}}$ commute with errors drawn from $\mathcal{E}^{Z}$ and are therefore symmetries. The set of all such $S_{\mathcal{L}}$ generate $\mathcal{S}_{\text{sym}}$ with respect to $\mathcal{E}^{Z}$.

Now consider what this symmetry implies for an arbitrary syndrome in our error model. A direct consequence of the definition of a symmetry $\mathcal{S}_{\text{sym}}$ is that, for pure dephasing noise, there will always be an even number of defects measured by the subsets of stabilizers whose product gives elements of $\mathcal{S}_{\text{sym}}$. We can design a decoder that exploits this property of these subsets. Specifically, we can consistently pair the defects detected by the stabilizers of these subsets using, say, MWPM, or another suitable pairing algorithm such as that of Ref. Delfosse and Nickerson (2017). Collections of defects that are combined with pairing operations on sufficiently many symmetries can be neutralized with a low-weight Pauli operator. We say that such a collection is locally correctable Brown and Williamson (2020). For the surface code under pure dephasing noise, by performing pairing over the one-dimensional lattice symmetries, the edges returned from MWPM form the boundary of the error; see Fig. 1(right). The interior of the boundary determines the correction.

Such a decoder is readily extended to the fault-tolerant setting where measurements are unreliable and may give incorrect outcomes. A single measurement error will violate the defect symmetries of the two-dimensional system. Following the approach of Ref. Dennis et al. (2002), we can recover a new symmetry in the fault-tolerant setting in $(2+1)$-dimensional spacetime by repeating stabilizer measurements over time, see also Ref. Brown and Williamson (2020). A symmetry is recovered by taking the parity of pairs of sequential measurement outcomes, with odd parity heralding a defect. This spacetime symmetry is generic to our proposal here. In this situation, up to the lattice boundaries, the symmetries represent constraints among collections of defects lying on $(1+1)$-dimensional planes. Curiously, unlike the phenomenological bit-flip noise model for the surface code Wang et al. (2003); Raussendorf et al. (2006), the biased phenomenological error model considered here is anisotropic in spacetime. We emphasize the importance of checking for temporal logical errors, consisting of strings of sequential measurement errors, as they may introduce logical failures while performing code deformations Vuillot et al. (2019).

The symmetries of the system are altered at lattice boundaries. We can adapt the decoder to account for this, by adding a pair of defects at each time step to all vertices where a stabilizer is not imposed at the boundary; see Fig. 1(left). These defects can be paired to other defects within their respective $(1+1)$-dimensional planes of symmetry. Otherwise, they can be matched together freely in the case that they do not need to be paired.

Decoding with finite bias.

We next adapt our decoder to deal with low-rate $X$ and $Y$ errors in addition to high-rate $Z$ errors. For simplicity we will describe this modification for the case of periodic boundary conditions and where measurements are reliable. We give a technical description of all the decoders we present in the Supplemental Material.

The decoder for infinite bias noise will pair each defect of the system twice: once to a horizontally separated defect and once to a vertically separated defect. Low rate $X$ and $Y$ errors violate the one-dimensional symmetries that enable us to use the strategy described above, but we can weakly adhere to the strategy as follows. In our modified decoder we pair all defects twice: once where we strongly bias the decoder to pair defects horizontally, and a second time where we strongly bias each defect to pair vertically. Unlike in the infinite-bias case, we permit our decoder to pair defects that are not within their same row or column. We penalize such pairings according to the amount of noise bias. This can be achieved in our input into the MWPM algorithm by assigning high weights to edges for pairs of defects that are not aligned on the same row or column, depending on the respective matching.

In the case of finite bias the collections of defects that are connected through the edges returned by pairing may not be locally correctable. We deal with this issue with additional use of MWPM to complete the decoding procedure. One can show that there will be an even number of defects in each collection of defects connected by edges. Therefore, the parity of defects on black and white vertices are equal. We call collections of defects with an even (odd) parity of defects on black and white vertices ‘neutral’ (‘charged’). Neutral clusters can be locally corrected. Remaining charged collections of defects can be made neutral by pairing them with other nearby charged collections of defects. This final pairing ensures the collections of connected defects are locally correctable.

Biased noise models.

We will test our decoder under two scenarios: with a biased noise model and ideal measurements, and with a phenomenological biased noise model with unreliable measurements. At each time step, qubits are subjected to an error with probability $p$. Pauli $Z$ errors occur at high rate $p_{\text{h.r.}}=p\eta/(\eta+1)$, while $X$ and $Y$ errors occur at a lower rate, $p_{\text{l.r.}}=p/2(\eta+1)$. The phenomenological (ideal-measurement) biased noise model gives an incorrect measurement outcome with probability $q=p$ ($q=0$).

It is important to consider whether the phenomenological noise model we introduced is compatible with a noise-bias setting Aliferis and Preskill (2008). As we now demonstrate, it is possible to measure stabilizers and maintain the bias. Following the standard approach Dennis et al. (2002), stabilizers are measured by preparing an ancilla, $a$, in an eigenstate of $X$, then applying entangling gates between the ancilla and the qubits that support the stabilizer, and finally measuring the ancilla qubit in the $X$ basis. To measure $S_{v}$ for black vertices $v$ we apply $\prod_{\partial f\ni v}CX_{a,f}$ where $CX_{a,f}=(1+Z_{a}+X_{f}-Z_{a}X_{f})/2$ is the controlled-not gate. To measure white vertex stabilizers, we replace the $CX_{a,f}$ gates with $CY_{a,f}$ gates. These gates differ by an $\exp(\text{i}\pi Z_{f}/2)$ rotation.

We can now justify that stabilizer measurements performed this way preserve the noise bias. Specifically, we demonstrate that no steps in the stabilizer circuit cause high-rate errors to introduce $X$ or $Y$ errors to the data qubits of the surface code. The $CX_{a,f}$ commutes with $Z$ errors that act on the ancilla. As such, it will not create high rate $X$ or $Y$ errors on the data qubits. Similarly, the single-qubit rotation that maps $CX_{a,f}$ onto $CY_{a,f}$ commutes with the high-rate errors, and will therefore only map low-rate errors onto other low-rate errors. Ancilla qubits are vulnerable to high-rate Pauli $Z$ errors. This is reflected by the error model that has a high measurement error rate, $q=p$. An additional concern is that the entangling gates such as $CX_{a,f}$ may increase the frequency that low-rate errors occur. This will depend on the physical implementation, and recent proposals have demonstrated that noise-bias-preserving $CX_{a,f}$ gates are indeed possible in some architectures Puri et al. (2019).

Numerical simulations.

We simulate the performance of our decoder for the surface code with periodic boundary conditions against the phenomenological biased noise model, using 30 000 trials per code distance and physical error probability. We used the critical exponent method of Ref. Wang et al. (2003), fitting to a quadratic model, to obtain threshold estimates with jackknife resampling over code distances to determine error bounds. Because of the anisotropy in spacetime, we might expect the thresholds of logical errors in the spatial and temporal direction to differ. We report a failure if a logical error occurs in either the spatial or temporal direction. Our results are shown in Fig. 2. We identify a threshold of $6.32(3)\%$ for pure dephasing, and thresholds of $\sim 5\%$ for biases around $\eta=100$. Our decoder begins to outperform the optimal values for standard methods, where bit-flip and dephasing errors are corrected separately, at $\eta\sim 5$. These results demonstrate the advantage of using our decoder in the fault-tolerant setting, even if the noise bias is modest.

We have simulated the performance on the surface code with boundaries, yielding similar results. Figure 3 demonstrates a threshold using the fault-tolerant decoder for the surface code with boundaries where $\eta=100$. In this case we only measure spatial logical errors because there are no topologically nontrivial temporal errors. Remarkably, the threshold is very similar to the threshold obtained in the case with periodic boundary conditions where we also count logical failures along the temporal direction as well. This is surprising given the anisotropy of the decoding problem in the spatial and temporal directions.

We benchmark our decoder against the optimal performance of the surface code under the biased noise model. In the absence of optimal fault-tolerant thresholds (say, from statistical mechanical arguments Chubb and Flammia (2019)), we benchmark using the ideal measurement model. In this case, optimal performance corresponds to the zero-rate hashing bound, which is achievable using a ML decoder Bravyi et al. (2014); Tuckett et al. (2018b). We see in Fig. 4 that our decoder underperforms in comparison to the ML decoder, suggesting that there is considerable scope for further improvements. A natural proposal would be to incorporate belief propagation into the MWPM algorithm. Choices of boundary conditions also play a role. We note that our decoder applied to the surface code with boundaries can achieve the optimal threshold of $p_{\text{th.}}\sim 1/2$ for pure dephasing noise. However it underperforms similarly to that shown in Fig. 4 at finite biases.

Low error rates.

The performance of the decoder below threshold will determine the resources required to perform quantum computation. We now speculate on the logical failure rates where the physical error rate is low, specifically $p\ll 1/d$. Using conventional decoding methods the logical failure rate decays as $\mathcal{O}(p^{\delta\sqrt{n}})$ Dennis et al. (2002); Beverland et al. (2019) with $n=d\times d$ the code length and $\delta$ a constant. The high-threshold at infinite bias is indicative that the decoder can tolerate up to $\sim n/2$ dephasing errors  Tuckett et al. (2018a, b). We may therefore expect that the logical failure rate will decay with improved scaling, $\mathcal{O}({p_{\text{h.r.}}}^{\alpha n})$, for some constant $\alpha$.

At finite noise bias, the improved scaling in logical failure rate with $n$ can only persist up to some critical system size. Above some system size that depends on $\eta$, we expect that the most likely error that will cause a logical failure will be due a string consisting of $\sim\sqrt{n}$ low-rate errors. Up to constant factors, this will occur for some $n$ where ${p_{\text{h.r.}}}^{\alpha n}\ll{p_{\text{l.r.}}}^{\delta\sqrt{n}}$. Nevertheless, given high bias, the decoder will vastly improve logical error rates in the regime where the most likely failure mechanisms are due to long strings of low-rate error events.

We contrast this with bias nullification schemes by concatenation Stephens et al. (2013); Xu et al. (2018). These approaches increase the effective rate that uncommon errors act on the surface code by a factor equal to the number of qubits of each repetition code, leading to worse performance at low error rates. Moreover, they can only tolerate at most $\propto\sqrt{n}$ high-rate errors.

Extending again to the fault-tolerant case, temporal-logical errors are caused by strings of measurement errors that occur at a high rate. We should consider increasing the number of repetitions $T$ of the error-correction cycle between code deformations to reduce the likelihood of temporal logical failures. Choosing $T\sim 2\delta\sqrt{n}\log p_{\text{l.r.}}/\log p$ will ensure temporal errors will occur at a rate similar to spatial logical errors, $\sim{p_{\text{l.r.}}}^{\delta\sqrt{n}}$, where we have assumed a temporal logical error occurs with likelihood $\sim p^{T/2}$. To achieve the target logical failure rate of the system, although the qubits will be occupied for a longer time to decrease the failure rate of temporal logical errors, the associated decrease in the two spatial dimensions will result in a net improvement on resource scaling using our system.

Discussion.

Minimum-weight perfect matching has formed the backbone of topological quantum error correction Dennis et al. (2002); Wang et al. (2003); Raussendorf et al. (2006); Brown and Williamson (2020); Fowler et al. (2012a); Delfosse (2014); Kubica and Delfosse (2019). The realization that we can design MWPM decoders with knowledge of the symmetries of the code or system opens up a number of new avenues for decoding algorithm design. A multitude of codes have yet to be explored, as well as their interaction with specialized noise models that reflect the errors that occur in the laboratory. Significant improvements in fault-tolerant thresholds obtained though tailored codes and realistic noise models, such as those we have demonstrated here, offer great promise for the realization of practical quantum technologies.

I Supplemental material

Here, we provide technical details of the decoding algorithm implementation and some examples of its operation. This complements the conceptual description we give in the letter.

I.1 Decoder implementation

Consider the tailored surface codes defined in the letter, with qubits on the faces and $X$- and $Y$-type stabilizers on the black and white vertices, respectively. The input to the decoding algorithm is an error syndrome, and some assumed noise parameters. The output of the decoding algorithm is a recovery operator that returns the code to the codespace. The syndrome is generated from repeated stabilizer measurements [2], such that defects are identified with vertex locations in time where the parity of successive pairs of stabilizer measurements is odd. We label defects as $X$- or $Y$-type depending on whether they are due to $X$- or $Y$-type stabilizer checks.

The decoding algorithm, see Algorithm 1, exploits symmetries of the code and noise model in the following way. A graph is constructed with two nodes, labeled horizontal (H) and vertical (V), for each defect. Edges are added between similarly oriented nodes and weighted by a distance function, described in more detail below. Nodes of the graph are paired using minimum-weight perfect matching (MWPM) and the defects identified with the nodes are grouped into clusters by following the path traced out by matched pairs of nodes. In the case of pure Z noise, these clusters are guaranteed to have an even parity of each type of defect; such even-parity clusters are locally correctable and we refer to them as neutral. In the case of finite bias, clusters are guaranteed to have the same parity of each type of defect but this parity may be odd; such odd-parity clusters are not locally correctable and we refer to them as charged. Having locally corrected the clusters as far as possible, the decoding algorithm invokes a residual decoding sub-algorithm, see Algorithm 3, that again uses MWPM to pair charged clusters, possibly through neutral clusters, ensuring the code is returned to the codespace.

The graph used in the main decoding algorithm is key to exploiting the symmetries of the code and noise model. As mentioned above, the graph contains a pair of nodes, labeled H and V, for each syndrome defect, and edges are added between similarly oriented nodes (i.e. H to H and V to V), with edge weights given by a distance function. (For a code with boundaries, an additional pair of virtual H and V nodes is added and connected with zero weight, at each boundary vertex where a stabilizer is not applied.) The distance function, see Algorithm 2, breaks the path between nodes into time, parallel and diagonal steps. Parallel steps are along horizontal (vertical) lines on the lattice between H (V) nodes. Measurement errors displace defects in time steps, high-rate $Z$ errors displace defects in parallel steps, and low-rate $X$ or $Y$ errors displace defects in diagonal steps. Each of these steps is weighted as a function of the noise parameters: bias, qubit error probability and measurement error probability. The minimum distance between nodes is found by minimizing the number of diagonal, parallel and time steps in that order of priority, and then returning the weighted sum over these steps. Figure 5 gives some examples of paths between H and V nodes broken into parallel and diagonal steps.

The derivation of step weights as functions of the noise parameters is as follows. Consider the code, with stabilizer measurements repeated over a fixed number of time steps, represented by a (2+1)-dimensional lattice with a total of $N$ qubit locations (one for each physical qubit at each time step) and $M$ stabilizer measurement locations (one for each stabilizer measurement at each time step). The probability of an error configuration, $E$, consisting of $H$ high-rate qubit errors, $L$ low-rate qubit errors and $Q$ measurement errors, is given by

[TABLE]

where $p$, $p_{\text{h.r.}}$, $p_{\text{l.r.}}$ and $q$ are the probabilities of any qubit error, a high-rate qubit error, a low-rate qubit error, and a measurement error, respectively. Noting that $N$ and $M$ are constant for a fixed number of time steps, we have

[TABLE]

where $k$ is a constant independent of the error configuration. Recalling, from the letter, that $p_{\text{h.r.}}=p\eta/(\eta+1)$ and $p_{\text{l.r.}}=p/(2(\eta+1))$, where $\eta$ is the noise bias, we see that the time, parallel and diagonal step weights, as functions of $\eta$, $p$ and $q$ can be defined, respectively, as

[TABLE]

Examples showing the operation of the main decoding algorithm, assuming reliable measurements, can be seen in Figures 6, 7 and 8. Each figure shows: (a) an error and corresponding syndrome defects; (b) vertical/horizontal nodes added to the graph for the given syndrome defects; (c) matching of nodes resulting from MWPM over the graph; (d) cluster of defects corresponding to the matching; and (e) recovery operator resulting from neutralizing the defects in the cluster. Figure 6 shows the successful correction of an infinite bias error on a periodic lattice. Figure 7 shows the successful correction of an infinite bias error on a lattice with boundaries. Figure 8 shows the successful correction of an error due to finite bias noise on a periodic lattice.

I.2 Decoder runtime

The runtime of the decoder is determined by the runtime of the pairing subroutine. With our choice of minimum-weight perfect matching, a single subroutine has runtime $O(v^{3})$, where $v$ is the number of vertices of the input graph. On average, in the main decoding step, we have $v\sim 8pd^{2}$ for the ideal-measurement case and $v\sim 8pd^{3}$ for the fault-tolerant case, where $p$ is the error rate and $d$ is the code distance. We include a constant prefactor $8=2\times 4$; the factor $4$ is included because each error introduces at most four defects, and the factor $2$ is included because for each defect we introduce two vertices to the graph. We neglect the vertices that allow us to pair defects to the boundary; for large system sizes, this contribution is negligibly small compared to the number of vertices that appear in the bulk.

In the finite-bias case, we use minimum-weight perfect matching again to pair charged clusters in a residual decoding step. This also scales like $O(d^{2})$ and $O(d^{3})$ for the ideal-measurement and fault-tolerant cases, respectively. However, in practice, this residual step is very fast compared to the main decoding step.

We note that we can choose any pairing subroutine to combine defects. For instance, we could use the union-find decoder due to Delfosse and Nickerson [32] to reduce the runtime from $O(v^{3})$ to almost $v$.

With periodic boundary conditions and at infinite noise bias, decoding is readily parallelized into several two-dimensional pairing subroutines [31]. Moreover, in the infinite bias case, the residual decoding step is not required. We can therefore reduce the single pairing problem of $v\sim 8pd^{3}$ vertices in the fault-tolerant case into $2d$ subroutines of $v\sim 2pd^{2}$ vertices. One may consider ways to parallelize the decoder in settings where we include boundaries or when the noise bias is finite. We leave this to future work.