Concatenation Schemes for Topological Fault-tolerant Quantum Error Correction

We investigate a family of fault-tolerant quantum error correction schemes based on the concatenation of small error detection or error correction codes with the three-dimensional cluster state. We propose fault-tolerant state preparation and decoding schemes that effectively convert every circuit-level error into an erasure error, leveraging the cluster state's high threshold against such errors. We find a set of codes for which such a conversion is possible, and study their performance against the standard circuit-level depolarizing model. Our best performing scheme, which is based on a concatenation with a classical code, improves the threshold by $16.5\%$ and decreases the spacetime overhead by $32\%$ compared to the scheme without concatenation, with each scheme subject to a physical error rate of $10^{-3}$ and achieving a logical error rate of $10^{-6}$.


Introduction
Quantum computers are expected to provide substantial speedups for a number of practical problems of interest, such as factoring, quantum chemistry, and the simulation of physical models that describe nature [12,24,51].However, the ubiquitous presence of noise makes qubits very fragile and easily affected by their environment, which can cause them to decohere.
The fault tolerance threshold theorem [2,8,17,21,53] provides a foundation for the long-term development of quantum computers despite the presence of noise.This theorem states that there is a finite error rate below which a noisy quantum computer can simulate a noiseless quantum computer with an error rate that can be made to be arbitrarily small, while only paying a polylogarithmic overhead in space and time.More practically, this theorem asserts that building an effectively noiseless quantum computer is in principle possible.
However, in order to build such a quantum computer, one must develop a fault-tolerant quantum computation scheme that is experimentally achievable.The figures of merit that are often considered in the literature can be divided into three categories: threshold, overhead, and connectivity.The threshold is an error rate below which scaling up the system decreases the logical error rate.As such, it is desirable to have a system with a higher threshold.Overhead is the ratio of the number of physical qubits to logical qubits, which is a metric best minimized if possible.Lastly, connectivity refers to the set of gates that can be applied between the qubits in the quantum computer.For this last category, it is desirable to have requirements compatible with the capabilities of the actual hardware.
Kitaev's surface code [21] has been the major focus of research on practical fault tolerance over the past two decades.The surface code boasts a high threshold and can be realized with qubits connected in a twodimensional square lattice, making it the leading candidate architecture for early-generation fault-tolerant quantum computers.
A more traditional approach to fault tolerance was based on concatenated codes.While the associated codes form the major underpinning of the early theory of fault tolerance, the estimated threshold of the schemes tends to be lower; see Ref. [13] for example.However, one notable exception to this rule is Knill's fault tolerance scheme, which is based on postselection [29][30][31].
Postselection is a technique in which one accepts an outcome only if a certain set of criteria is satisfied.For example, in magic state distillation, one accepts the distilled magic state only if all the syndrome measurements report +1.Knill's key insight was that the threshold for postselection schemes tends to be higher than fault-tolerant quantum error correction schemes.Of course, if one relies on postselection alone, the probability of accepting the result of a post-selected computation decreases exponentially with the number of post-selected operations, making this approach impractical [29,30].However, what one can do is concatenate such a scheme with another code that can deal with the events in which the postselection procedure does not accept the outcome.While Knill's scheme is based on the concatenation of a postselection scheme with a fault-tolerant concatenated quantum error correction scheme, there is a viable alternative: concatenating a postselection scheme with the surface code, or equivalently the three-dimensional (3D) cluster state.It is well-known that these schemes [54] have high thresholds against loss compared to Pauli noise.Therefore, one can hope to improve the logical error rate by converting weight-1 Pauli errors to erasure errors, by declaring loss if the postselection scheme does not accept.The main purpose of this paper is to provide a careful study of this idea.
This paper reports a comprehensive study in this direction for a variety of small quantum error correcting codes concatenated with the 3D cluster state [42,44,45].The codes we employ can be broadly classified into two categories.The first category, which we refer to as Type I codes, involves codes for which the concatenation can be implemented straightforwardly using the fault-tolerant logical gates available to those codes.While we observe a general increase in threshold against the phenomenological noise model, these codes are less effective against circuit-level noise.The second category, which we refer to as Type II codes, are codes for which some of the logic gates used are not obviously fault-tolerant in the sense that a single error can propagate to multiple errors in the other code block.Somewhat surprisingly, some of these codes outperform the bcc cluster state, even against circuit-level noise.
We attribute this fact to a surprising property of our state preparation circuit: any single-qubit circuitlevel noise operator as well as the two-qubit circuitlevel noise operator that are implemented with the CZ gates propagate, up to stabilizers, to a tensor product of errors on disjoint code blocks which are detectable from the syndrome information within that block.In particular, upon measuring this code block, one can convert the Pauli error into an erasure error.Importantly, via this process, every single-qubit circuit-level noise operator propagates to an erasure error of the 3D cluster state.Because the logical gates used for the codes of Type II are not obviously fault-tolerant, the fact that we can achieve this conversion is not obvious.
We note that there has been significant recent work studying a concatenation of the 3D cluster state, or equivalently the 2D surface code, with more hardware-efficient codes [6,23,33,39,40,58,61,63,64].While the underlying idea is similar, there is a crucial difference.The prior work exploits some special structures in the noise or concatenates with a more hardware-specific scheme, e.g., the Gottesman-Kitaev-Preskill (GKP) code.On the other hand, our scheme does not make these extra assumptions.In particular, it should be possible to concatenate these schemes with our scheme, which may lead to further improvements.
The rest of this paper is structured as follows.In Section 2, we introduce stabilizer codes, cluster states, and concatenation schemes.In Section 3, we demonstrate two types of concatenation schemes for fault-tolerant quantum error correction.In Section 4, numerical simulations are performed to study the threshold error rate of these schemes.Finally, in Section 5, we use numerical and analytical results to explain the low-error behavior of the qubit overhead.

Background
In this section, we review known facts about quantum error correction that are relevant to this work.

Stabilizer codes
A stabilizer code is a subspace spanned by the joint +1 eigenstates of the elements of the stabilizer group [25].A stabilizer group is a commutative subgroup of the Pauli group which does not contain −I ⊗n as an element.Following the usual convention, we shall say a code is an n, k, d -code if the stabilizer group is over n qubits, the number of logical qubits is k, and the code distance is d.
The topological code of particular relevance to this paper is Kitaev's surface code [28].This code boasts a high threshold and planar connectivity, making it one of the leading approaches to building a largescale fault-tolerant quantum computer.It is wellknown that there is an intimate relationship between the surface code and the 3D cluster state, which is a resource state for fault-tolerant quantum computation [42,44,45].
A cluster state is a quantum state defined in terms of a graph G = (V, E), where V is the set of vertices and E is a set of edges.More specifically, the cluster state |ψ G ⟩ is defined as the unique state over |V | qubits -labeled in terms of v ∈ V -determined by the following equation: for all v ∈ V .Alternatively, |ψ G ⟩ can be defined as: where |+⟩ = |0⟩+|1⟩ √ 2 and CZ u,v is the controlled-Z gate between u and v. Thus, the cluster state can be created by preparing all the qubits in the |+⟩ state and applying a sequence of CZ gates.
The 3D cluster state [43,45] is a cluster state defined over a graph G bcc , a bcc lattice; see Figure 1.The importance of the 3D cluster state comes from the fact that it is a resource state for fault-tolerant measurement-based quantum computation.For instance, by measuring all but the bottom and top layers of Figure 1, up to a Pauli correction, we can establish a logical Bell pair between two surface code states at the bottom and top layers.It is possible to obtain the surface code from the 3D cluster state through the process of foliation [5].Moreover, the surface code state can be fault-tolerantly teleported by measuring consecutive layers of the 3D cluster state in the X-basis [43].In a fault-tolerant cluster state quantum computation, Z-basis measurements are only used for removing the vertices of the graph that defines the cluster state [10].Y -basis measurements are used only when applying a logical S-gate.[11].Therefore, for the purpose of storing a quantum information fault-tolerantly, it suffices to use only X-basis measurements.
Thus, while we shall primarily work with the 3D cluster state in this paper, the conclusions made, for instance, on the threshold and the overhead, are easily translatable to that of the surface code.We note in passing that the concatenation scheme may be applicable to other cluster states using crystalline structures [36,38].We leave such studies for future work.

Concatenation
In this paper, we propose a fault-tolerant quantum error correction scheme based on concatenating the 3D cluster state with a quantum error-correcting code.We aim to construct a state we denote as |ψ G,C ⟩, where G = (V, E) is a graph and C is a stabilizer code that encodes a single logical qubit.Doing so requires performing logical operators on the logical qubit, which we will refer to as a code block of physical qubits.Specifically, given C, let |+⟩ be its logical |+⟩ state and let CZ u,v be a logical CZ gate between two code blocks, labeled by u, v ∈ V .The state |ψ G,C ⟩ is defined as One can formally view |ψ G,C ⟩ as a state living in a code v∈V C v .While our main focus lies in fault-tolerant quantum error correction, let us remark that, insofar as the state in Eq. (3) can be prepared, the basic ingredients of fault-tolerant quantum computation delineated in Ref. [45] can be implemented in a straightforward way.The Clifford gates could be performed with logical X and Z measurements, assisted by an ancillary +1 eigenstate of the Pauli-Y operator [21].The faulty magic state can be encoded into a code block by performing an (unprotected) magic-basis measurement [34], followed by distillation [7].Thus, a universal set of fault-tolerant quantum gates can be implemented using the state in Eq. (3).

Concatenation schemes
In this section, we describe the concatenation schemes in detail.To explain our principle for choosing codes, we first need to explain our approach to decoding.For fault-tolerant error correction, it suffices to perform logical X-basis measurements for each code block, i.e. the inner codes, feed the measurement outcomes to higher-level decoding algorithms, such as the minimum-weight perfect matching (MWPM) decoder [21,42] or the union-find decoder [20], and apply the appropriate Pauli correction.We shall refer to these algorithms as outer decoding algorithms.The standard inputs to these decoding algorithms are the X-basis measurement results of the individual physical qubits.Applied to our setup, one way to decode our scheme would be to perform a destructive logical X-basis measurement for every vertex and feed the logical measurement outcome to an outer decoding algorithm.
However, at least when it comes to the threshold, we consider it unlikely for this approach to be able to outperform the body-centered cubic (bcc) cluster state (without concatenation).The main reason is that, to the best of our knowledge, there is no quantum error correcting code whose pseudothreshold 1 is above the fault-tolerant quantum error correction threshold of the 3D cluster state.If the pseudothreshold is lower than the threshold of the bcc cluster state, the overall threshold of the scheme will be limited by it.This argument suggests that, unless more information is passed from the lower level to the outer decoder [41], improvements in threshold are likely unachievable.
This is why we seek to consider a different decoding algorithm in which information from the code C is passed to the outer decoding algorithm.To that end, we remark on a few facts that are relevant to our choice of inner codes.First of all, both MWPM and union-find decoders can also easily accommodate erasure errors.In particular, these decoders boast a much higher threshold for erasure error than for Pauli noise.Secondly, for the bcc cluster state with the phenomenological noise model, i.e., a model in which a noiseless cluster state is subjected to an identical independent noise model, the threshold for the depolarizing noise is ∼ 3% whereas the threshold against loss is 25% [3].Thirdly, when an error is detected at a low level, instead of correcting the error, one can instead opt to artificially "lose" that logical qubit by erasing it.This information can be fed into the outer decoder as an erasure error.This Pauli-to-loss conversion of the error model is the main idea behind our decoding scheme.
To make this idea work, we must choose the code C such that there is a circuit that prepares the state |ψ G bcc ,C ⟩ in such a way that any single circuit-level error propagates to an error convertible to a (possibly correlated) erasure error upon applying the destructive logical X-basis measurement of C. If C is a Calderbank-Shor-Steane (CSS) code, the X-basis measurement is unaffected by any X-error.Thus, in order to make a circuit-level error detectable from the logical X measurement of C, it suffices for the propagated error to be equivalent up to stabilizers and Pauli-X operators to a tensor product of Paulis over different code blocks, such that the individual errors within each code block are detectable.More formally, we propose the following definition.
Let us first define the circuit-level error.A circuitlevel error is an error occurring after individual gates, specifically, on a set of qubits the gate acts on.For instance, if we have a noisy CZ gate, its circuit-level noise will be one or two-qubit Paulis occurring at the qubits that the CZ gate acts on.We now define what it means for these errors to be C-detectable.Definition 3.1.Let C be a CSS code.Consider a circuit that prepares |ψ G,C ⟩.A circuit-level noise operator is C-detectable if the noise, up to some stabilizer and Pauli-X operators S, is of the following form: where P v is an error detectable with respect to C. There's a subtle difference between C-detectability and conventional fault-tolerant circuits.For a faulttolerant gadget [2], the output must contain at most one fault, whereas C-detectability only requires the number of faults to be within the detection ability of the inner code up to stabilizers and X operators.If we can create a C-detectable state preparation circuit, we can convert circuit-level errors to erasure errors of the outer code.
The main question we address in this Section is whether there are circuits preparing the state |ψ bcc,C ⟩ in a C-detectable way.We discuss two families of such codes.The first family consists of codes that are equipped with a fault-tolerant logical |+⟩-state preparation and logical (transversal) CZ gate.Such codes, by using these operations, come with a natural C-detectable state preparation circuit.We refer to the inner codes used in these constructions as Type I codes.
Surprisingly, we find that there are choices of inner codes without any fault-tolerant logical CZ gates, which nevertheless admit a C-detectable state preparation circuits for |ψ bcc,C ⟩.We refer to these inner codes as Type II codes.

Type I
We consider two examples of Type I codes: a 4, 1, 1, 2 subsystem code [35] 2 and the Steane code [55].The stabilizers of the 4, 1, 1, 2 are given by X 1 X 2 , Z 1 Z 3 , XXXX and ZZZZ, and the logical operations are given by Transversal logical CZ gate construction is trivially possible.Moreover, 4, 1, 1, 2 concatenation with the surface code, which is unitary-equivalent to a 4.8.8 color code, has been studied previously [16].
Another code we consider is the 7, 1, 3 Steane code, whose stabilizers are This is also the smallest 2D color code [4].
Since both codes admit transversal CZ gates, Z errors are local throughout the whole circuit.On the other hand, although a CZ gate will propagate X errors to Z errors, transversality guarantees at most one error will present in a given code block, which could be effectively corrected or detected by the inner code.

Type II
In this section, we introduce Type II codes using up to 4 qubits.We first introduce the 2, 1, 1 repetition code.The stabilizer group of the 2, 1, 1 code is ⟨{X 1 X 2 }⟩ and the logical operators are The logical CZ gate can be applied by applying a physical CZ gate to every pair of connected qubits in Figure 2. A state preparation for the logical |+⟩ state entails preparing the | + +⟩ state.Thus, no extra entangling gate is needed in the encoding procedure.The concatenated geometric structure, as shown in Figure 3, is referred to as double-edge cubic lattice in Ref. [37] and is equivalent to the crazy-graph construction with n = 2 of the bcc lattice [48].
For 3, 1, 1 codes, two different constructions exist.The 3, 1, 1 1 code is the three-qubit repetition code.The CZ gate can be performed with nine applications of physical CZ gates [57], as shown in Figure 4a.
For larger repetition codes, we could in principle perform a CZ gate by applying O(n 2 ) CZ gates.However, we expect the threshold to decrease as n increases.Our numerical simulation shows that, indeed, 3, 1, 1 1 code performs worse than the 2, 1, 1 code.
The 3, 1, 1 2 code can be viewed as an "interpolation" between the 2, 1, 1 code and the 4, 1, 1, 2 code, which is manifested by its logical operators defined by Z = Z 1 Z 3 and X = X 1 .The logical CZ gate of this code is shown in Figure 4b. .
Because none of the codes mentioned in this section can detect an arbitrary single-qubit error, it is a priori not obvious why there should be a C-detectable state preparation procedure.We claim below that this is nevertheless the case, by showing explicit examples.Consider the gate sequence in Figure 5.In the ensuing discussion we shall refer to the individual code blocks as central (C), northern (N), southern (S), western (W), and eastern (E), depending on their relative location with respect to the central block.Since every code block can be interpreted as a central block and the scheduling in Figure 5 can be applied in a uniform way throughout the entire lattice, it suffices to consider single-qubit errors occurring on the central block and two-qubit errors that can occur after each CZ gate.
Let us first consider single-qubit errors.Since CZ gates commute with Z errors, Z errors do not propagate and remain C-detectable.For a single-qubit X error occurring in the central block, we make the following observation: if such an error occurs after Step 4, it propagates to a tensor product of single-qubit Z errors and identity on the N, S, E, and W code blocks.Therefore, in this case, the error propagates to a C-detectable error.On the other hand, if an error occurs between Step 1 and Step 4, it propagates to a tensor product of single or two-qubit Z errors within each block.Although a two-qubit error within a block is a logical Z error of that code, the propagated error is still C-detectable because the resulting error is equivalent, up to an outer code stabilizer, to a tensor product of single-qubit Z errors and identity on each code block.Specifically, the stabilizer is given by Moreover, all the two-qubit circuit-level errors propagate to 2, 1, 1 -detectable errors.We have investigated how these errors propagate, up to stabilizers, the result of which is summarized in Appendix A. We also note that the schemes based on the 3, 1, 1 1 and the 3, 1, 1 2 code are C-detectable; see Appendix A.
We emphasize that the ordering of the gates in Figure 5 is important.This gate sequence is in particular different from the "natural" gate sequence proposed in Ref. [57] that applies all physical CZ gates of a logical CZ gate consecutively (shown in Figure 6).As one can see in Figure 6, there are circuit-level errors which propagate to errors that are not 2, 1, 1detectable.Thus, the fact that all circuit-level errors are 2, 1, 1 -detectable is a special property of the circuit shown in Figure 5.The inner codes and their respective stabilizers and logical operators are summarized in Table 1.
Step 1 Step 2 Step 3 Step 5 Step 6 Step 7 Step 8 Figure 6: "Natural" gate sequence of the 2, 1, 1 scheme that fails to be C-detectable.Note that a single-qubit X error happening on one of the central qubits could propagate to two undetectable errors in the N and S blocks.

Thresholds
In this Section, we discuss the performance of our schemes against the phenomenological noise model and the circuit-level noise model in terms of the threshold error rate.After measuring all the qubits in the X-basis, the decoder works in two steps.First, if an error is detected in any individual code block, that code block is erased.If not, the measured logical information of that code block is passed to the higher level decoder, which we choose to be the MWPM decoder with Manhattan norm.We use the Blossom V algorithm [32] with 10 6 trials to get each data point.We perform the simulation on lattices of varying size L, ranging from 3 to 19.
Table 1: Definitions of the inner codes in the stabilizer formalism and their respective logical operators.

Phenomenological noise model
The phenomenological noise model is a model in which the noiseless cluster state |ψ G,C ⟩ is subjected to a depolarizing noise channel D p : on each qubit3 .We expect the logical error rate p L to obey the following scaling relation near the threshold: Fitting to the quadratic scaling ansatz [59] with parameters A i , p th , and ν, we obtain a threshold of 8.034(3)%.
Intuitively, we can understand the value of this threshold in terms of an effective error model on the bcc cluster state.For instance, for the 2, 1, 1 scheme, upon converting the error detected from the code C to an erasure error, we obtain an effective model in which the rates for Pauli (p P ) and erasure (p E ) errors are The model effectively defines a path along the phase diagram of the bcc cluster state as shown in Figure 7.We note that the values of the effective p P and p E obtained at our threshold are consistent with the thresholds for the respective parameters obtained in Ref. [3].The conversion of the Pauli errors into loss errors generally leads to improvements in thresholds, as summarized in Table 2.  a Our data agrees with the reported results from [59] Table 2: Thresholds of the concatenation schemes against phenomenological noise.

Circuit-level noise model
A more realistic error model should take into account errors in individual operations, which we analyze as follows.We assume that the logical |+⟩ state of the code C is prepared perfectly, followed by independent depolarizing noise on every physical qubit.After that, every gate is followed by depolarizing noise, i.e. each two-qubit error can occur with probability p/15, and measurements are preceded by depolarizing noise as well.Finally, we also assume that idle qubits experience depolarizing noise. 4 One may wonder about the motivation behind our non-standard choice of modeling the logical |+⟩ state 4 We note in passing that, unlike the other codes, the 3, 1, 1 2 code requires one more idle timestep for two of the qubits, in order to have consistent global scheduling of the gates.We have ignored the extra error incurred in this step.However, the conclusion of our work does not depend significantly on this choice.
preparation as a perfect preparation followed by depolarizing noise.This is because there are known methods to boost the fidelity of such states using methods such as post-selection [15,46,50].As such, the result of these simulations can be thought of as the best-case-scenario threshold one can hope to get, after incorporating such techniques.
We also note that such an error model reduces to the standard circuit-level depolarizing noise model if the logical |+⟩ state is a product state.In our case, there are two examples: the 2, 1, 1 and the 3, 1, 1 1 code.Therefore, for these codes, one can interpret the result as the true threshold against the standard circuit-level noise model.
After the state is prepared, all the qubits are measured in the X-basis.Applying the decoding algorithm in Section 3, we estimate the logical error rate; see Table 3 for the summary.We note that the thresholds are generally better than the bcc cluster state, except for the 3, 1, 1 1 -code-based scheme.
Taking into account our non-standard logical |+⟩ state preparation error modeling, we can interpret these results as follows.First of all, because our model reduces to the standard circuit-level noise model for the 2, 1, 1 and the 3, 1, 1 1 code, these results can be compared fairly against the other schemes in the literature.We note that the 2, 1, 1 scheme improves upon the threshold of the bcc scheme, whereas the 3, 1, 1 1 scheme does not.Since repetition codes involving a larger number of qubits will require even more gates, we can therefore expect that n, 1, 1 code-based constructions for n > 3 will likely yield worse results.Secondly, for the other schemes, e.g., 3, 1, 1 2 , 4, 1, 1, 2 , and 7, 1, 3 , we see improvements in the threshold.Therefore, if we can utilize the high-fidelity logical state preparation schemes, e.g., Ref. [47,49], we can expect to again have improvements against the bcc scheme.However, we note that a more naive state preparation circuit does not yield improvements.For instance, we studied the state preparation circuit for the 4, 1, 1, 2 in which one prepares the logical |+⟩|0⟩ state, which can be prepared fault-tolerantly by preparing two Bell pairs.Even for such a simple circuit, we observed a lower threshold than the bcc cluster state, which is shown in Figure 8.

Biased noise model
In this section, we study our schemes against the biased noise.We remark that the following analysis is not based on an explicit Monte Carlo simulation.Rather, it is based on an exact mapping of the biased noise model to the phenomenological noise model by exploiting the fact that Z errors do not propagate through the circuit.
In this model, the two-qubit noise in Section 4.2 is replaced with an error model completely biased to Z-  error.For instance, for the two-qubit gates, we apply the following noise model.
This error model is equivalent to a limiting case of the error model studied in Ref. [57], with the bias parameter β taken to be infinity, i.e. we essentially suppress the propagation of gate level noise.Subsequently, the model reduces to an independent error model whose resulting threshold error rate can be calculated by a counting argument.For instance, the 2, 1, 1 scheme results in an effective noise parameter of p = 4•2•p CZ +p M +p I = 4•2•2p/3+4p/3 = 20p/3, leading to a p th of 1.205(1)% 5 .Unsurprisingly, the scheme is extremely tolerant to biased noise, as indicated by the effective error rate listed in Table 4. 5 Our results point out a possible systematic inconsistency in Ref. [57], as the presented numerical results exceed the worstcase scenario delineated by our semi-analytic approach.

Overhead
We now study the overhead of our schemes assuming a range of aspirational but reasonable circuit-level noise rates.Overall, we note that the only scheme that leads to a lower overhead is based on the 2, 1, 1 code.
As such, we primarily focus on this code.A particularly interesting regime is an error rate approaching 10 −3 .This error rate is slightly lower than what can currently be achieved experimentally.As such, studies of overhead in this parameter range can provide an accurate estimate of the overhead required in realistic quantum computers.
Normally, the logical error rate decays exponentially with the code distance L. However, our numerical study shows that there are effects that make the fitting to an exponentially decaying function unreliable, which may be a result of the interplay between the decoder and the inner code [22].Thus, we first focus on demonstrating improvements in overheads in the high-error-rate regime, based on our Monte Carlo simulation.We then explain, based on a combinatorial argument, why we anticipate this improvement to persist in a lower error rate regime as well.
Due to the aforementioned effects, we cannot reliably extrapolate the suppression of p L , and the overhead advantage may not exist for large L. As shown in Figure 9, the error suppresion relation for the 2, 1, 1 scheme are convex in the log-log plot and eventually crosses that of the bcc scheme.However, we can in-stead interpolate the data to fairly compare the overhead of our 2, 1, 1 scheme to the bcc cluster state when L is not that large.We fit the logical error rate at every physical error rate with the function e a+bL+cL 3 to account for those effects 6 .From this, we can infer overhead for the overall spacetime volume scaling as sL 2 , where s is the block size of the inner code.The 2, 1, 1 scheme outperforms the bcc scheme in this regime, as shown in Figure 9.Here the dots represent data points of the 2, 1, 1 scheme and the circles represent that of the bcc scheme.
For smaller and more practical p th values, numerical simulation fails to give accurate results due to the diverging time to convergence.However, the following analytical argument, based on the leading-order approximation, suggests that even in this regime we expect to have lower overhead.
For the bcc lattice with periodic boundary conditions in two directions and a smooth boundary on the third, p L for a single logical X operator, to the leading order, scales approximately as [62]: where L 2 counts the number of lowest weight logical operators that percolate to the two rough boundaries.Thus p L = o(p L/2 ) as p → 0 and L → ∞.
For the 2, 1, 1 scheme with the same boundary condition, a length L path could fit in N ∈ {1, • • • , L} erasure errors, and the effective code distance is reduced to L − N .Using the effective p P and p L relations outlined in Subsection 4.1, p L is given by 6 The choice of the qubic non-linear term is to accommodate to the numerical methods.
which scales as o(p L ) as p → 0 and L → ∞.Moreover, this quantity is upper-bounded by as L → ∞, which is, in turn, upper-bounded by Eq. 11.
Since the 2, 1, 1 scheme only contributes to a constant factor in the overhead, in the low-noise regime we expect to have better performance in terms of resource usage.For the other concatenated schemes, due to C-detectability, the logical Pauli error rate p scales as o(p i ) with some i ≥ 2. Therefore, we expect similar results to hold.At around p L = 10 −6 and p = 10 −3 , the overhead value is listed in Table 5.

Conclusions
We have identified a fault-tolerant quantum error correction scheme that effectively converts circuitlevel Pauli errors to erasure errors.Besides the much higher phenomenological error threshold compared with regular foliated topological quantum codes [5], our scheme also demonstrates improvements in circuit-level error thresholds, indicating a path to practical performance advantage.We have restricted our discussion to decoding by the MWPM algorithm with Manhattan norm weightings.Using better decoding schemes, employing lattice correlations, or utilizing predecoders will likely lead to even more improvements [9,14,18,19,52,60].Furthermore, different outer codes, such as those with > 50% erasure thresholds [37], could be used in similar constructions 7 .Lastly, we leave it as an open problem to convert our scheme to a two-dimensional architecture and study its performance against the standard surface code.
ical error rate scaling of the toric code.

A Effective error model
The effective circuit-level error model is obtained by conjugating all single-qubit and two-qubit error operators to the end of the circuit.Here, the tables show the errors defined by the noise model and the resulting effective error after propagation.

Error
Step Effective error Table 6: Propagated circuit-level errors for type I codes with the trivial circuit.

Error
Step Effective error Step Effective error Table 7: Propagated circuit-level errors for the 2, 1, 1 scheme.The circuit employs the 2, 1, 1 -detectable gate sequence demonstrated in the Fig. 5.

Error
Step Effective error Step Effective error Step Effective error Table 8: Circuit-level errors for the 3, 1, 1 1 scheme.The circuit is 3, 1, 1 1-detectable by applying transversal gate sequences for 3 rounds.

B Scaling exponents
The scaling exponent ν obtained from fitting is listed as follows.

C Threshold simulations
The raw data obtained from our numerical simulation is plotted in the following diagrams.

Figure 1 :
Figure 1: Illustration of the Raussendorf lattice.There are two types of qubits in the lattice, the magenta balls represent primal qubits and the cyan balls represent dual qubits.The linkage between the balls represents CZ gate applications.

Figure 7 :
Figure 7: Phase diagram for the bcc scheme[42,44,45], here pE and pP are the loss and Pauli error rates, respectively, and pL is the logical error rate.The grayscale surface is the section of effective loss-error relationship for the 2, 1, 1 scheme, from which we can directly read off the error threshold of approximately 8.03%.
(a) Error threshold of the bcc scheme (b) Error threshold of the 2, 1, 1 scheme

Figure 8 :
Figure 8: Comparison of error threshold under circuit-level noise.Note that the dashed lines in the figure represent data that suffer from finite size effects and are therefore excluded from the fitting process.

Figure 9 :
Figure 9: Relationship of pL v.s.L at different p values.Here the dots represent data points of the 2, 1, 1 scheme and the circles represent that of the bcc scheme.

Figure 10 :
Figure 10: Logical error probability of the bcc scheme under the phenomenological noise model.

Figure 11 :
Figure 11: Logical error probability of the 2, 1, 1 scheme under the phenomenological noise model.

Figure 18 :
Figure 18: Logical error probability of the 7, 1, 3 scheme under the phenomenological noise model.

Figure 19 :
Figure 19: Logical error probability of the 7, 1, 3 scheme under the circuit-level noise model.
Definition 3.2.Let C be a CSS code.Consider a circuit that prepares |ψ G,C ⟩.This circuit is Cdetectable if every circuit-level Pauli noise operator is C-detectable.

Table 3 :
Threshold of the concatenation schemes against circuit-level noise model, assuming that the initial encoded logical state of the code is prepared perfectly, followed by a depolarizing noise model on all the qubits.

Table 4 :
Thresholds of the concatenation schemes against biased noise model.

Table 5 :
Ratio of overhead between concatenation schemes Lc and the bcc scheme L.

Table 9 :
Scaling exponents of the concatenation schemes against the phenomenological and circuit-level noise model.